]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2484 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2485 #define SWIGTYPE_p_wxColour swig_types[23]
2486 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2487 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2488 #define SWIGTYPE_p_wxControl swig_types[26]
2489 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2490 #define SWIGTYPE_p_wxCursor swig_types[28]
2491 #define SWIGTYPE_p_wxDC swig_types[29]
2492 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2493 #define SWIGTYPE_p_wxDateTime swig_types[31]
2494 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2496 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2497 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEvent swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2500 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2501 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2502 #define SWIGTYPE_p_wxFSFile swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2504 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2505 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2506 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2507 #define SWIGTYPE_p_wxFont swig_types[45]
2508 #define SWIGTYPE_p_wxFrame swig_types[46]
2509 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2510 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2511 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2512 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2513 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2514 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2515 #define SWIGTYPE_p_wxICOHandler swig_types[53]
2516 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
2517 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
2518 #define SWIGTYPE_p_wxImage swig_types[56]
2519 #define SWIGTYPE_p_wxImageHandler swig_types[57]
2520 #define SWIGTYPE_p_wxImageHistogram swig_types[58]
2521 #define SWIGTYPE_p_wxImage_HSVValue swig_types[59]
2522 #define SWIGTYPE_p_wxImage_RGBValue swig_types[60]
2523 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[61]
2524 #define SWIGTYPE_p_wxInitDialogEvent swig_types[62]
2525 #define SWIGTYPE_p_wxInputStream swig_types[63]
2526 #define SWIGTYPE_p_wxInternetFSHandler swig_types[64]
2527 #define SWIGTYPE_p_wxItemContainer swig_types[65]
2528 #define SWIGTYPE_p_wxJPEGHandler swig_types[66]
2529 #define SWIGTYPE_p_wxKeyEvent swig_types[67]
2530 #define SWIGTYPE_p_wxLayoutConstraints swig_types[68]
2531 #define SWIGTYPE_p_wxMaximizeEvent swig_types[69]
2532 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
2533 #define SWIGTYPE_p_wxMenu swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBar swig_types[72]
2535 #define SWIGTYPE_p_wxMenuBarBase swig_types[73]
2536 #define SWIGTYPE_p_wxMenuEvent swig_types[74]
2537 #define SWIGTYPE_p_wxMenuItem swig_types[75]
2538 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMouseEvent swig_types[77]
2540 #define SWIGTYPE_p_wxMoveEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNcPaintEvent swig_types[80]
2543 #define SWIGTYPE_p_wxNotifyEvent swig_types[81]
2544 #define SWIGTYPE_p_wxObject swig_types[82]
2545 #define SWIGTYPE_p_wxOutputStream swig_types[83]
2546 #define SWIGTYPE_p_wxPCXHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNGHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPNMHandler swig_types[86]
2549 #define SWIGTYPE_p_wxPaintEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[88]
2551 #define SWIGTYPE_p_wxPaperSize swig_types[89]
2552 #define SWIGTYPE_p_wxPoint swig_types[90]
2553 #define SWIGTYPE_p_wxPoint2D swig_types[91]
2554 #define SWIGTYPE_p_wxPropagateOnce swig_types[92]
2555 #define SWIGTYPE_p_wxPropagationDisabler swig_types[93]
2556 #define SWIGTYPE_p_wxPyApp swig_types[94]
2557 #define SWIGTYPE_p_wxPyCommandEvent swig_types[95]
2558 #define SWIGTYPE_p_wxPyDropTarget swig_types[96]
2559 #define SWIGTYPE_p_wxPyEvent swig_types[97]
2560 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyImageHandler swig_types[99]
2562 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
2563 #define SWIGTYPE_p_wxPySizer swig_types[101]
2564 #define SWIGTYPE_p_wxPyValidator swig_types[102]
2565 #define SWIGTYPE_p_wxQuantize swig_types[103]
2566 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[104]
2567 #define SWIGTYPE_p_wxRealPoint swig_types[105]
2568 #define SWIGTYPE_p_wxRect swig_types[106]
2569 #define SWIGTYPE_p_wxRegion swig_types[107]
2570 #define SWIGTYPE_p_wxScrollEvent swig_types[108]
2571 #define SWIGTYPE_p_wxScrollWinEvent swig_types[109]
2572 #define SWIGTYPE_p_wxSetCursorEvent swig_types[110]
2573 #define SWIGTYPE_p_wxShowEvent swig_types[111]
2574 #define SWIGTYPE_p_wxSize swig_types[112]
2575 #define SWIGTYPE_p_wxSizeEvent swig_types[113]
2576 #define SWIGTYPE_p_wxSizer swig_types[114]
2577 #define SWIGTYPE_p_wxSizerItem swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBox swig_types[116]
2579 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[117]
2580 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[118]
2581 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[119]
2582 #define SWIGTYPE_p_wxTIFFHandler swig_types[120]
2583 #define SWIGTYPE_p_wxToolTip swig_types[121]
2584 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[122]
2585 #define SWIGTYPE_p_wxValidator swig_types[123]
2586 #define SWIGTYPE_p_wxVisualAttributes swig_types[124]
2587 #define SWIGTYPE_p_wxWindow swig_types[125]
2588 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[126]
2589 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[127]
2590 #define SWIGTYPE_p_wxXPMHandler swig_types[128]
2591 #define SWIGTYPE_p_wxZipFSHandler swig_types[129]
2592 static swig_type_info *swig_types[131];
2593 static swig_module_info swig_module = {swig_types, 130, 0, 0, 0, 0};
2594 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2595 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2596
2597 /* -------- TYPES TABLE (END) -------- */
2598
2599 #if (PY_VERSION_HEX <= 0x02000000)
2600 # if !defined(SWIG_PYTHON_CLASSIC)
2601 # error "This python version requires to use swig with the '-classic' option"
2602 # endif
2603 #endif
2604 #if (PY_VERSION_HEX <= 0x02020000)
2605 # error "This python version requires to use swig with the '-nomodern' option"
2606 #endif
2607 #if (PY_VERSION_HEX <= 0x02020000)
2608 # error "This python version requires to use swig with the '-nomodernargs' option"
2609 #endif
2610 #ifndef METH_O
2611 # error "This python version requires to use swig with the '-nofastunpack' option"
2612 #endif
2613
2614 /*-----------------------------------------------
2615 @(target):= _core_.so
2616 ------------------------------------------------*/
2617 #define SWIG_init init_core_
2618
2619 #define SWIG_name "_core_"
2620
2621 #define SWIGVERSION 0x010329
2622
2623
2624 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2625 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2626
2627
2628 #include <stdexcept>
2629
2630
2631 namespace swig {
2632 class PyObject_ptr {
2633 protected:
2634 PyObject *_obj;
2635
2636 public:
2637 PyObject_ptr() :_obj(0)
2638 {
2639 }
2640
2641 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2642 {
2643 Py_XINCREF(_obj);
2644 }
2645
2646 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2647 {
2648 if (initial_ref) Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr & operator=(const PyObject_ptr& item)
2652 {
2653 Py_XINCREF(item._obj);
2654 Py_XDECREF(_obj);
2655 _obj = item._obj;
2656 return *this;
2657 }
2658
2659 ~PyObject_ptr()
2660 {
2661 Py_XDECREF(_obj);
2662 }
2663
2664 operator PyObject *() const
2665 {
2666 return _obj;
2667 }
2668
2669 PyObject *operator->() const
2670 {
2671 return _obj;
2672 }
2673 };
2674 }
2675
2676
2677 namespace swig {
2678 struct PyObject_var : PyObject_ptr {
2679 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2680
2681 PyObject_var & operator = (PyObject* obj)
2682 {
2683 Py_XDECREF(_obj);
2684 _obj = obj;
2685 return *this;
2686 }
2687 };
2688 }
2689
2690
2691 #include "wx/wxPython/wxPython_int.h"
2692 #include "wx/wxPython/pyclasses.h"
2693 #include "wx/wxPython/twoitem.h"
2694
2695
2696 #ifndef wxPyUSE_EXPORT
2697 // Helper functions for dealing with SWIG objects and such. These are
2698 // located here so they know about the SWIG types and functions declared
2699 // in the wrapper code.
2700
2701 #include <wx/hashmap.h>
2702 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2703
2704
2705 // Maintains a hashmap of className to swig_type_info pointers. Given the
2706 // name of a class either looks up the type info in the cache, or scans the
2707 // SWIG tables for it.
2708 extern PyObject* wxPyPtrTypeMap;
2709 static
2710 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2711
2712 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2713
2714 if (typeInfoCache == NULL)
2715 typeInfoCache = new wxPyTypeInfoHashMap;
2716
2717 wxString name(className);
2718 swig_type_info* swigType = (*typeInfoCache)[name];
2719
2720 if (! swigType) {
2721 // it wasn't in the cache, so look it up from SWIG
2722 name.Append(wxT(" *"));
2723 swigType = SWIG_TypeQuery(name.mb_str());
2724
2725 // if it still wasn't found, try looking for a mapped name
2726 if (!swigType) {
2727 PyObject* item;
2728 name = className;
2729
2730 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2731 (char*)(const char*)name.mbc_str())) != NULL) {
2732 name = wxString(PyString_AsString(item), *wxConvCurrent);
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735 }
2736 }
2737 if (swigType) {
2738 // and add it to the map if found
2739 (*typeInfoCache)[className] = swigType;
2740 }
2741 }
2742 return swigType;
2743 }
2744
2745
2746 // Check if a class name is a type known to SWIG
2747 bool wxPyCheckSwigType(const wxChar* className) {
2748
2749 swig_type_info* swigType = wxPyFindSwigType(className);
2750 return swigType != NULL;
2751 }
2752
2753
2754 // Given a pointer to a C++ object and a class name, construct a Python proxy
2755 // object for it.
2756 PyObject* wxPyConstructObject(void* ptr,
2757 const wxChar* className,
2758 int setThisOwn) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2762
2763 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2764 }
2765
2766
2767 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2768 // Ensures that the proxy object is of the specified (or derived) type. If
2769 // not able to perform the conversion then a Python exception is set and the
2770 // error should be handled properly in the caller. Returns True on success.
2771 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2772 const wxChar* className) {
2773
2774 swig_type_info* swigType = wxPyFindSwigType(className);
2775 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2776
2777 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2778 }
2779
2780
2781
2782 // Make a SWIGified pointer object suitable for a .this attribute
2783 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2784
2785 PyObject* robj = NULL;
2786
2787 swig_type_info* swigType = wxPyFindSwigType(className);
2788 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2789
2790 robj = PySwigObject_New(ptr, swigType, 0);
2791 return robj;
2792 }
2793
2794
2795 // Python's PyInstance_Check does not return True for instances of new-style
2796 // classes. This should get close enough for both new and old classes but I
2797 // should re-evaluate the need for doing instance checks...
2798 bool wxPyInstance_Check(PyObject* obj) {
2799 return PyObject_HasAttrString(obj, "__class__") != 0;
2800 }
2801
2802
2803 // This one checks if the object is an instance of a SWIG proxy class (it has
2804 // a .this attribute, and the .this attribute is a PySwigObject.)
2805 bool wxPySwigInstance_Check(PyObject* obj) {
2806 static PyObject* this_str = NULL;
2807 if (this_str == NULL)
2808 this_str = PyString_FromString("this");
2809
2810 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2811 if (this_attr) {
2812 bool retval = (PySwigObject_Check(this_attr) != 0);
2813 Py_DECREF(this_attr);
2814 return retval;
2815 }
2816
2817 PyErr_Clear();
2818 return false;
2819 }
2820
2821
2822 // Export a C API in a struct. Other modules will be able to load this from
2823 // the wx._core_ module and will then have safe access to these functions,
2824 // even if they are located in another shared library.
2825 static wxPyCoreAPI API = {
2826
2827 wxPyCheckSwigType,
2828 wxPyConstructObject,
2829 wxPyConvertSwigPtr,
2830 wxPyMakeSwigPtr,
2831
2832 wxPyBeginAllowThreads,
2833 wxPyEndAllowThreads,
2834 wxPyBeginBlockThreads,
2835 wxPyEndBlockThreads,
2836
2837 wxPy_ConvertList,
2838
2839 wxString_in_helper,
2840 Py2wxString,
2841 wx2PyString,
2842
2843 byte_LIST_helper,
2844 int_LIST_helper,
2845 long_LIST_helper,
2846 string_LIST_helper,
2847 wxPoint_LIST_helper,
2848 wxBitmap_LIST_helper,
2849 wxString_LIST_helper,
2850 wxAcceleratorEntry_LIST_helper,
2851
2852 wxSize_helper,
2853 wxPoint_helper,
2854 wxRealPoint_helper,
2855 wxRect_helper,
2856 wxColour_helper,
2857 wxPoint2D_helper,
2858
2859 wxPySimple_typecheck,
2860 wxColour_typecheck,
2861
2862 wxPyCBH_setCallbackInfo,
2863 wxPyCBH_findCallback,
2864 wxPyCBH_callCallback,
2865 wxPyCBH_callCallbackObj,
2866 wxPyCBH_delete,
2867
2868 wxPyMake_wxObject,
2869 wxPyMake_wxSizer,
2870 wxPyPtrTypeMap_Add,
2871 wxPy2int_seq_helper,
2872 wxPy4int_seq_helper,
2873 wxArrayString2PyList_helper,
2874 wxArrayInt2PyList_helper,
2875
2876 wxPyClientData_dtor,
2877 wxPyUserData_dtor,
2878 wxPyOORClientData_dtor,
2879
2880 wxPyCBInputStream_create,
2881 wxPyCBInputStream_copy,
2882
2883 wxPyInstance_Check,
2884 wxPySwigInstance_Check,
2885
2886 wxPyCheckForApp
2887
2888 };
2889
2890 #endif
2891
2892
2893 #if !WXWIN_COMPATIBILITY_2_4
2894 #define wxHIDE_READONLY 0
2895 #endif
2896
2897
2898 #define SWIG_From_long PyInt_FromLong
2899
2900
2901 SWIGINTERNINLINE PyObject *
2902 SWIG_From_int (int value)
2903 {
2904 return SWIG_From_long (value);
2905 }
2906
2907 static const wxString wxPyEmptyString(wxEmptyString);
2908 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2909 return self->GetClassInfo()->GetClassName();
2910 }
2911 SWIGINTERN void wxObject_Destroy(wxObject *self){
2912 delete self;
2913 }
2914
2915 #ifndef __WXMAC__
2916 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2917 #endif
2918
2919
2920 #include <limits.h>
2921 #ifndef LLONG_MIN
2922 # define LLONG_MIN LONG_LONG_MIN
2923 #endif
2924 #ifndef LLONG_MAX
2925 # define LLONG_MAX LONG_LONG_MAX
2926 #endif
2927 #ifndef ULLONG_MAX
2928 # define ULLONG_MAX ULONG_LONG_MAX
2929 #endif
2930
2931
2932 SWIGINTERN int
2933 SWIG_AsVal_long (PyObject* obj, long* val)
2934 {
2935 if (PyNumber_Check(obj)) {
2936 if (val) *val = PyInt_AsLong(obj);
2937 return SWIG_OK;
2938 }
2939 return SWIG_TypeError;
2940 }
2941
2942
2943 SWIGINTERN int
2944 SWIG_AsVal_int (PyObject * obj, int *val)
2945 {
2946 long v;
2947 int res = SWIG_AsVal_long (obj, &v);
2948 if (SWIG_IsOK(res)) {
2949 if ((v < INT_MIN || v > INT_MAX)) {
2950 return SWIG_OverflowError;
2951 } else {
2952 if (val) *val = static_cast< int >(v);
2953 }
2954 }
2955 return res;
2956 }
2957
2958 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2959 wxSize temp, *obj = &temp;
2960 if ( other == Py_None ) return false;
2961 if ( ! wxSize_helper(other, &obj) ) {
2962 PyErr_Clear();
2963 return false;
2964 }
2965 return self->operator==(*obj);
2966 }
2967 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2968 wxSize temp, *obj = &temp;
2969 if ( other == Py_None ) return true;
2970 if ( ! wxSize_helper(other, &obj)) {
2971 PyErr_Clear();
2972 return true;
2973 }
2974 return self->operator!=(*obj);
2975 }
2976 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 PyObject* tup = PyTuple_New(2);
2979 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2980 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2981 wxPyEndBlockThreads(blocked);
2982 return tup;
2983 }
2984
2985 SWIGINTERN int
2986 SWIG_AsVal_double (PyObject *obj, double* val)
2987 {
2988 if (PyNumber_Check(obj)) {
2989 if (val) *val = PyFloat_AsDouble(obj);
2990 return SWIG_OK;
2991 }
2992 return SWIG_TypeError;
2993 }
2994
2995
2996 #define SWIG_From_double PyFloat_FromDouble
2997
2998 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2999 wxRealPoint temp, *obj = &temp;
3000 if ( other == Py_None ) return false;
3001 if ( ! wxRealPoint_helper(other, &obj) ) {
3002 PyErr_Clear();
3003 return false;
3004 }
3005 return self->operator==(*obj);
3006 }
3007 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3008 wxRealPoint temp, *obj = &temp;
3009 if ( other == Py_None ) return true;
3010 if ( ! wxRealPoint_helper(other, &obj)) {
3011 PyErr_Clear();
3012 return true;
3013 }
3014 return self->operator!=(*obj);
3015 }
3016 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3017 self->x = x;
3018 self->y = y;
3019 }
3020 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3025 wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3029 wxPoint temp, *obj = &temp;
3030 if ( other == Py_None ) return false;
3031 if ( ! wxPoint_helper(other, &obj) ) {
3032 PyErr_Clear();
3033 return false;
3034 }
3035 return self->operator==(*obj);
3036 }
3037 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3038 wxPoint temp, *obj = &temp;
3039 if ( other == Py_None ) return true;
3040 if ( ! wxPoint_helper(other, &obj)) {
3041 PyErr_Clear();
3042 return true;
3043 }
3044 return self->operator!=(*obj);
3045 }
3046 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3047 self->x = x;
3048 self->y = y;
3049 }
3050 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3051 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3052 PyObject* tup = PyTuple_New(2);
3053 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3054 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3055 wxPyEndBlockThreads(blocked);
3056 return tup;
3057 }
3058 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3059 wxRect temp, *obj = &temp;
3060 if ( other == Py_None ) return false;
3061 if ( ! wxRect_helper(other, &obj) ) {
3062 PyErr_Clear();
3063 return false;
3064 }
3065 return self->operator==(*obj);
3066 }
3067 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3068 wxRect temp, *obj = &temp;
3069 if ( other == Py_None ) return true;
3070 if ( ! wxRect_helper(other, &obj)) {
3071 PyErr_Clear();
3072 return true;
3073 }
3074 return self->operator!=(*obj);
3075 }
3076 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3077 self->x = x;
3078 self->y = y;
3079 self->width = width;
3080 self->height = height;
3081 }
3082 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(4);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3088 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3089 wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092
3093 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3094 wxRegion reg1(*r1);
3095 wxRegion reg2(*r2);
3096 wxRect dest(0,0,0,0);
3097 PyObject* obj;
3098
3099 reg1.Intersect(reg2);
3100 dest = reg1.GetBox();
3101
3102 if (dest != wxRect(0,0,0,0)) {
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxRect* newRect = new wxRect(dest);
3105 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3106 wxPyEndBlockThreads(blocked);
3107 return obj;
3108 }
3109 Py_INCREF(Py_None);
3110 return Py_None;
3111 }
3112
3113 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3114 wxPoint2D temp, *obj = &temp;
3115 if ( other == Py_None ) return false;
3116 if ( ! wxPoint2D_helper(other, &obj) ) {
3117 PyErr_Clear();
3118 return false;
3119 }
3120 return self->operator==(*obj);
3121 }
3122 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3123 wxPoint2D temp, *obj = &temp;
3124 if ( other == Py_None ) return true;
3125 if ( ! wxPoint2D_helper(other, &obj)) {
3126 PyErr_Clear();
3127 return true;
3128 }
3129 return self->operator!=(*obj);
3130 }
3131 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3132 self->m_x = x;
3133 self->m_y = y;
3134 }
3135 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3136 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 PyObject* tup = PyTuple_New(2);
3138 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3139 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3140 wxPyEndBlockThreads(blocked);
3141 return tup;
3142 }
3143
3144 #include "wx/wxPython/pyistream.h"
3145
3146 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3147 wxInputStream* wxis = wxPyCBInputStream::create(p);
3148 if (wxis)
3149 return new wxPyInputStream(wxis);
3150 else
3151 return NULL;
3152 }
3153
3154 SWIGINTERN swig_type_info*
3155 SWIG_pchar_descriptor()
3156 {
3157 static int init = 0;
3158 static swig_type_info* info = 0;
3159 if (!init) {
3160 info = SWIG_TypeQuery("_p_char");
3161 init = 1;
3162 }
3163 return info;
3164 }
3165
3166
3167 SWIGINTERNINLINE PyObject *
3168 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3169 {
3170 if (carray) {
3171 if (size > INT_MAX) {
3172 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3173 return pchar_descriptor ?
3174 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3175 } else {
3176 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3177 }
3178 } else {
3179 return SWIG_Py_Void();
3180 }
3181 }
3182
3183
3184 SWIGINTERNINLINE PyObject *
3185 SWIG_From_char (char c)
3186 {
3187 return SWIG_FromCharPtrAndSize(&c,1);
3188 }
3189
3190
3191 SWIGINTERNINLINE PyObject*
3192 SWIG_From_unsigned_SS_long (unsigned long value)
3193 {
3194 return (value > LONG_MAX) ?
3195 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3196 }
3197
3198
3199 SWIGINTERNINLINE PyObject *
3200 SWIG_From_size_t (size_t value)
3201 {
3202 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3203 }
3204
3205
3206 SWIGINTERN int
3207 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3208 {
3209 if (PyString_Check(obj)) {
3210 char *cstr; int len;
3211 PyString_AsStringAndSize(obj, &cstr, &len);
3212 if (cptr) {
3213 if (alloc) {
3214 /*
3215 In python the user should not be able to modify the inner
3216 string representation. To warranty that, if you define
3217 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3218 buffer is always returned.
3219
3220 The default behavior is just to return the pointer value,
3221 so, be careful.
3222 */
3223 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3224 if (*alloc != SWIG_OLDOBJ)
3225 #else
3226 if (*alloc == SWIG_NEWOBJ)
3227 #endif
3228 {
3229 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3230 *alloc = SWIG_NEWOBJ;
3231 }
3232 else {
3233 *cptr = cstr;
3234 *alloc = SWIG_OLDOBJ;
3235 }
3236 } else {
3237 *cptr = PyString_AsString(obj);
3238 }
3239 }
3240 if (psize) *psize = len + 1;
3241 return SWIG_OK;
3242 } else {
3243 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3244 if (pchar_descriptor) {
3245 void* vptr = 0;
3246 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3247 if (cptr) *cptr = (char *) vptr;
3248 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3249 if (alloc) *alloc = SWIG_OLDOBJ;
3250 return SWIG_OK;
3251 }
3252 }
3253 }
3254 return SWIG_TypeError;
3255 }
3256
3257
3258 SWIGINTERN int
3259 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3260 {
3261 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3262 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3263 if (SWIG_IsOK(res)) {
3264 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3265 if (csize <= size) {
3266 if (val) {
3267 if (csize) memcpy(val, cptr, csize*sizeof(char));
3268 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3269 }
3270 if (alloc == SWIG_NEWOBJ) {
3271 delete[] cptr;
3272 res = SWIG_DelNewMask(res);
3273 }
3274 return res;
3275 }
3276 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3277 }
3278 return SWIG_TypeError;
3279 }
3280
3281
3282 SWIGINTERN int
3283 SWIG_AsVal_char (PyObject * obj, char *val)
3284 {
3285 int res = SWIG_AsCharArray(obj, val, 1);
3286 if (!SWIG_IsOK(res)) {
3287 long v;
3288 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3289 if (SWIG_IsOK(res)) {
3290 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3291 if (val) *val = static_cast< char >(v);
3292 } else {
3293 res = SWIG_OverflowError;
3294 }
3295 }
3296 }
3297 return res;
3298 }
3299
3300 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3301 // We use only strings for the streams, not unicode
3302 PyObject* str = PyObject_Str(obj);
3303 if (! str) {
3304 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3305 return;
3306 }
3307 self->Write(PyString_AS_STRING(str),
3308 PyString_GET_SIZE(str));
3309 Py_DECREF(str);
3310 }
3311
3312 #include "wx/wxPython/pyistream.h"
3313
3314
3315 class wxPyFileSystemHandler : public wxFileSystemHandler
3316 {
3317 public:
3318 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3319
3320 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3321 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3322 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3323 DEC_PYCALLBACK_STRING__pure(FindNext);
3324
3325 wxString GetProtocol(const wxString& location) {
3326 return wxFileSystemHandler::GetProtocol(location);
3327 }
3328
3329 wxString GetLeftLocation(const wxString& location) {
3330 return wxFileSystemHandler::GetLeftLocation(location);
3331 }
3332
3333 wxString GetAnchor(const wxString& location) {
3334 return wxFileSystemHandler::GetAnchor(location);
3335 }
3336
3337 wxString GetRightLocation(const wxString& location) {
3338 return wxFileSystemHandler::GetRightLocation(location);
3339 }
3340
3341 wxString GetMimeTypeFromExt(const wxString& location) {
3342 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3343 }
3344
3345 PYPRIVATE;
3346 };
3347
3348
3349 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3350 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3351 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3352 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3353
3354
3355 SWIGINTERN int
3356 SWIG_AsVal_bool (PyObject *obj, bool *val)
3357 {
3358 if (obj == Py_True) {
3359 if (val) *val = true;
3360 return SWIG_OK;
3361 } else if (obj == Py_False) {
3362 if (val) *val = false;
3363 return SWIG_OK;
3364 } else {
3365 long v = 0;
3366 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3367 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3368 return res;
3369 }
3370 }
3371
3372 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3373 wxFileName fname = wxFileSystem::URLToFileName(url);
3374 return fname.GetFullPath();
3375 }
3376
3377 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3378 wxImage& image,
3379 long type) {
3380 wxMemoryFSHandler::AddFile(filename, image, type);
3381 }
3382
3383 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3384 const wxBitmap& bitmap,
3385 long type) {
3386 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3387 }
3388
3389 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3390 PyObject* data) {
3391 if (! PyString_Check(data)) {
3392 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3393 "Expected string object"));
3394 return;
3395 }
3396
3397 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3398 void* ptr = (void*)PyString_AsString(data);
3399 size_t size = PyString_Size(data);
3400 wxPyEndBlockThreads(blocked);
3401
3402 wxMemoryFSHandler::AddFile(filename, ptr, size);
3403 }
3404
3405
3406 #include "wx/wxPython/pyistream.h"
3407
3408
3409 SWIGINTERN int
3410 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3411 {
3412 long v = 0;
3413 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3414 return SWIG_TypeError;
3415 }
3416 else if (val)
3417 *val = (unsigned long)v;
3418 return SWIG_OK;
3419 }
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3424 {
3425 unsigned long v;
3426 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3427 if (SWIG_IsOK(res)) {
3428 if ((v > UCHAR_MAX)) {
3429 return SWIG_OverflowError;
3430 } else {
3431 if (val) *val = static_cast< unsigned char >(v);
3432 }
3433 }
3434 return res;
3435 }
3436
3437
3438 SWIGINTERNINLINE PyObject *
3439 SWIG_From_unsigned_SS_char (unsigned char value)
3440 {
3441 return SWIG_From_unsigned_SS_long (value);
3442 }
3443
3444 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3445 wxImageHistogramEntry e = (*self)[key];
3446 return e.value;
3447 }
3448 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3449 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3454 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3455 colour.Green(),
3456 colour.Blue());
3457 wxImageHistogramEntry e = (*self)[key];
3458 return e.value;
3459 }
3460
3461 typedef unsigned char* buffer;
3462
3463
3464 // Pull the nested class out to the top level for SWIG's sake
3465 #define wxImage_RGBValue wxImage::RGBValue
3466 #define wxImage_HSVValue wxImage::HSVValue
3467
3468 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3469 if (width > 0 && height > 0)
3470 return new wxImage(width, height, clear);
3471 else
3472 return new wxImage;
3473 }
3474 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3475 return new wxImage(bitmap.ConvertToImage());
3476 }
3477 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3478 if (DATASIZE != width*height*3) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3480 return NULL;
3481 }
3482
3483 // Copy the source data so the wxImage can clean it up later
3484 buffer copy = (buffer)malloc(DATASIZE);
3485 if (copy == NULL) {
3486 wxPyBLOCK_THREADS(PyErr_NoMemory());
3487 return NULL;
3488 }
3489 memcpy(copy, data, DATASIZE);
3490 return new wxImage(width, height, copy, false);
3491 }
3492 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3493 if (DATASIZE != width*height*3) {
3494 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3495 return NULL;
3496 }
3497 if (ALPHASIZE != width*height) {
3498 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3499 return NULL;
3500 }
3501
3502 // Copy the source data so the wxImage can clean it up later
3503 buffer dcopy = (buffer)malloc(DATASIZE);
3504 if (dcopy == NULL) {
3505 wxPyBLOCK_THREADS(PyErr_NoMemory());
3506 return NULL;
3507 }
3508 memcpy(dcopy, data, DATASIZE);
3509
3510 buffer acopy = (buffer)malloc(ALPHASIZE);
3511 if (acopy == NULL) {
3512 wxPyBLOCK_THREADS(PyErr_NoMemory());
3513 return NULL;
3514 }
3515 memcpy(acopy, alpha, ALPHASIZE);
3516
3517 return new wxImage(width, height, dcopy, acopy, false);
3518 }
3519 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3520 wxSize size(self->GetWidth(), self->GetHeight());
3521 return size;
3522 }
3523 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3524 buffer data = self->GetData();
3525 int len = self->GetWidth() * self->GetHeight() * 3;
3526 PyObject* rv;
3527 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3528 return rv;
3529 }
3530 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3531 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3532 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3533 return;
3534 }
3535 buffer copy = (buffer)malloc(DATASIZE);
3536 if (copy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return;
3539 }
3540 memcpy(copy, data, DATASIZE);
3541 self->SetData(copy, false);
3542 // wxImage takes ownership of copy...
3543 }
3544 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3545 buffer data = self->GetData();
3546 int len = self->GetWidth() * self->GetHeight() * 3;
3547 PyObject* rv;
3548 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3549 return rv;
3550 }
3551 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3552 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3553 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3554 return;
3555 }
3556 self->SetData(data, true);
3557 }
3558 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3559 buffer data = self->GetAlpha();
3560 if (! data) {
3561 RETURN_NONE();
3562 } else {
3563 int len = self->GetWidth() * self->GetHeight();
3564 PyObject* rv;
3565 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3566 return rv;
3567 }
3568 }
3569 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3570 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3571 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3572 return;
3573 }
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580 self->SetAlpha(acopy, false);
3581 // wxImage takes ownership of acopy...
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3588 return rv;
3589 }
3590 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3591 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3592 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3593 return;
3594 }
3595 self->SetAlpha(alpha, true);
3596 }
3597 SWIGINTERN PyObject *wxImage_GetHandlers(){
3598 wxList& list = wxImage::GetHandlers();
3599 return wxPy_ConvertList(&list);
3600 }
3601 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3602 wxBitmap bitmap(*self, depth);
3603 return bitmap;
3604 }
3605 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3606 wxImage mono = self->ConvertToMono( red, green, blue );
3607 wxBitmap bitmap( mono, 1 );
3608 return bitmap;
3609 }
3610 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3611 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3613 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3617 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3618 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3619 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3620 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3621 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3622 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3623 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3624 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3625
3626 #include <wx/quantize.h>
3627
3628 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3629 return wxQuantize::Quantize(src, dest,
3630 //NULL, // palette
3631 desiredNoColours,
3632 NULL, // eightBitData
3633 flags);
3634 }
3635 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3636 if (PyCallable_Check(func)) {
3637 self->Connect(id, lastId, eventType,
3638 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3639 new wxPyCallback(func));
3640 }
3641 else if (func == Py_None) {
3642 self->Disconnect(id, lastId, eventType,
3643 (wxObjectEventFunction)
3644 &wxPyCallback::EventThunker);
3645 }
3646 else {
3647 wxPyBLOCK_THREADS(
3648 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3649 }
3650 }
3651 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3652 return self->Disconnect(id, lastId, eventType,
3653 (wxObjectEventFunction)
3654 &wxPyCallback::EventThunker);
3655 }
3656 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3657 if (_self && _self != Py_None) {
3658 self->SetClientObject(new wxPyOORClientData(_self, incref));
3659 }
3660 else {
3661 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3662 if (data) {
3663 self->SetClientObject(NULL); // This will delete it too
3664 }
3665 }
3666 }
3667
3668 #if ! wxUSE_HOTKEY
3669 #define wxEVT_HOTKEY -9999
3670 #endif
3671
3672 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3673 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3674 if (data) {
3675 Py_INCREF(data->m_obj);
3676 return data->m_obj;
3677 } else {
3678 Py_INCREF(Py_None);
3679 return Py_None;
3680 }
3681 }
3682 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3683 wxPyClientData* data = new wxPyClientData(clientData);
3684 self->SetClientObject(data);
3685 }
3686 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3687 #if wxUSE_UNICODE
3688 return self->GetUnicodeKey();
3689 #else
3690 return 0;
3691 #endif
3692 }
3693
3694 SWIGINTERNINLINE PyObject *
3695 SWIG_From_unsigned_SS_int (unsigned int value)
3696 {
3697 return SWIG_From_unsigned_SS_long (value);
3698 }
3699
3700
3701 SWIGINTERN int
3702 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3703 {
3704 unsigned long v;
3705 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3706 if (SWIG_IsOK(res)) {
3707 if ((v > UINT_MAX)) {
3708 return SWIG_OverflowError;
3709 } else {
3710 if (val) *val = static_cast< unsigned int >(v);
3711 }
3712 }
3713 return res;
3714 }
3715
3716 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3717 self->m_size = size;
3718 }
3719 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3720 int count = self->GetNumberOfFiles();
3721 wxString* files = self->GetFiles();
3722 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3723 PyObject* list = PyList_New(count);
3724
3725 if (!list) {
3726 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3727 wxPyEndBlockThreads(blocked);
3728 return NULL;
3729 }
3730
3731 for (int i=0; i<count; i++) {
3732 PyList_SetItem(list, i, wx2PyString(files[i]));
3733 }
3734 wxPyEndBlockThreads(blocked);
3735 return list;
3736 }
3737
3738
3739 SWIGINTERN wxPyApp *new_wxPyApp(){
3740 wxPythonApp = new wxPyApp();
3741 return wxPythonApp;
3742 }
3743
3744 void wxApp_CleanUp() {
3745 __wxPyCleanup();
3746 }
3747
3748
3749 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3750
3751
3752
3753
3754
3755 SWIGINTERNINLINE PyObject *
3756 SWIG_FromCharPtr(const char *cptr)
3757 {
3758 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3759 }
3760
3761
3762 #if 0 // #ifdef __WXMAC__
3763
3764 // A dummy class that raises an exception if used...
3765 class wxEventLoop
3766 {
3767 public:
3768 wxEventLoop() { wxPyRaiseNotImplemented(); }
3769 int Run() { return 0; }
3770 void Exit(int rc = 0) {}
3771 bool Pending() const { return false; }
3772 bool Dispatch() { return false; }
3773 bool IsRunning() const { return false; }
3774 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3775 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3776 };
3777
3778 #else
3779
3780 #include <wx/evtloop.h>
3781
3782 #endif
3783
3784
3785
3786 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3787 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3788 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3789 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3790 wxWindowList& list = self->GetChildren();
3791 return wxPy_ConvertList(&list);
3792 }
3793 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3794 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3795 #if wxUSE_HOTKEY
3796 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3797 #else
3798 return false;
3799 #endif
3800 }
3801 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3802
3803
3804
3805 return false;
3806
3807 }
3808 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3809 return wxPyGetWinHandle(self);
3810 }
3811 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3812 self->AssociateHandle((WXWidget)handle);
3813 }
3814
3815 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3816 return wxWindow::FindWindowById(id, parent);
3817 }
3818
3819 wxWindow* wxFindWindowByName( const wxString& name,
3820 const wxWindow *parent = NULL ) {
3821 return wxWindow::FindWindowByName(name, parent);
3822 }
3823
3824 wxWindow* wxFindWindowByLabel( const wxString& label,
3825 const wxWindow *parent = NULL ) {
3826 return wxWindow::FindWindowByLabel(label, parent);
3827 }
3828
3829
3830 #ifdef __WXMSW__
3831 #include <wx/msw/private.h> // to get wxGetWindowId
3832 #endif
3833
3834
3835 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3836 #ifdef __WXMSW__
3837 WXHWND hWnd = (WXHWND)_hWnd;
3838 long id = wxGetWindowId(hWnd);
3839 wxWindow* win = new wxWindow;
3840 if (parent)
3841 parent->AddChild(win);
3842 win->SetEventHandler(win);
3843 win->SetHWND(hWnd);
3844 win->SetId(id);
3845 win->SubclassWin(hWnd);
3846 win->AdoptAttributesFromHWND();
3847 win->SetupColours();
3848 return win;
3849 #else
3850 wxPyRaiseNotImplemented();
3851 return NULL;
3852 #endif
3853 }
3854
3855
3856 PyObject* GetTopLevelWindows() {
3857 return wxPy_ConvertList(&wxTopLevelWindows);
3858 }
3859
3860
3861 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3863 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3864
3865 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3866
3867
3868 SWIGINTERNINLINE int
3869 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3870 {
3871 unsigned long v;
3872 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3873 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3874 return res;
3875 }
3876
3877 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3878 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3879 wxMenuItemList& list = self->GetMenuItems();
3880 return wxPy_ConvertList(&list);
3881 }
3882 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3883 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3884 static const wxString wxPyControlNameStr(wxControlNameStr);
3885 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3886 if (clientData) {
3887 wxPyClientData* data = new wxPyClientData(clientData);
3888 return self->Append(item, data);
3889 } else
3890 return self->Append(item);
3891 }
3892 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3893 if (clientData) {
3894 wxPyClientData* data = new wxPyClientData(clientData);
3895 return self->Insert(item, pos, data);
3896 } else
3897 return self->Insert(item, pos);
3898 }
3899 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3900 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3901 if (data) {
3902 Py_INCREF(data->m_obj);
3903 return data->m_obj;
3904 } else {
3905 Py_INCREF(Py_None);
3906 return Py_None;
3907 }
3908 }
3909 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3910 wxPyClientData* data = new wxPyClientData(clientData);
3911 self->SetClientObject(n, data);
3912 }
3913
3914
3915 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3916 wxPyUserData* data = NULL;
3917 if ( userData ) {
3918 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3919 data = new wxPyUserData(userData);
3920 wxPyEndBlockThreads(blocked);
3921 }
3922 return new wxSizerItem(window, proportion, flag, border, data);
3923 }
3924 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3925 wxPyUserData* data = NULL;
3926 if ( userData ) {
3927 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3928 data = new wxPyUserData(userData);
3929 wxPyEndBlockThreads(blocked);
3930 }
3931 return new wxSizerItem(width, height, proportion, flag, border, data);
3932 }
3933 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3934 wxPyUserData* data = NULL;
3935 if ( userData ) {
3936 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3937 data = new wxPyUserData(userData);
3938 wxPyEndBlockThreads(blocked);
3939 }
3940 return new wxSizerItem(sizer, proportion, flag, border, data);
3941 }
3942
3943 #include <float.h>
3944
3945
3946 SWIGINTERN int
3947 SWIG_AsVal_float (PyObject * obj, float *val)
3948 {
3949 double v;
3950 int res = SWIG_AsVal_double (obj, &v);
3951 if (SWIG_IsOK(res)) {
3952 if ((v < -FLT_MAX || v > FLT_MAX)) {
3953 return SWIG_OverflowError;
3954 } else {
3955 if (val) *val = static_cast< float >(v);
3956 }
3957 }
3958 return res;
3959 }
3960
3961
3962 SWIGINTERNINLINE PyObject *
3963 SWIG_From_float (float value)
3964 {
3965 return SWIG_From_double (value);
3966 }
3967
3968 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3969 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3970 if (data) {
3971 Py_INCREF(data->m_obj);
3972 return data->m_obj;
3973 } else {
3974 Py_INCREF(Py_None);
3975 return Py_None;
3976 }
3977 }
3978 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3979 wxPyUserData* data = NULL;
3980 if ( userData ) {
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 data = new wxPyUserData(userData);
3983 wxPyEndBlockThreads(blocked);
3984 }
3985 self->SetUserData(data);
3986 }
3987
3988 // Figure out the type of the sizer item
3989
3990 struct wxPySizerItemInfo {
3991 wxPySizerItemInfo()
3992 : window(NULL), sizer(NULL), gotSize(false),
3993 size(wxDefaultSize), gotPos(false), pos(-1)
3994 {}
3995
3996 wxWindow* window;
3997 wxSizer* sizer;
3998 bool gotSize;
3999 wxSize size;
4000 bool gotPos;
4001 int pos;
4002 };
4003
4004 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4005
4006 wxPySizerItemInfo info;
4007 wxSize size;
4008 wxSize* sizePtr = &size;
4009
4010 // Find out what the type of the item is
4011 // try wxWindow
4012 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4013 PyErr_Clear();
4014 info.window = NULL;
4015
4016 // try wxSizer
4017 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4018 PyErr_Clear();
4019 info.sizer = NULL;
4020
4021 // try wxSize or (w,h)
4022 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4023 info.size = *sizePtr;
4024 info.gotSize = true;
4025 }
4026
4027 // or a single int
4028 if (checkIdx && PyInt_Check(item)) {
4029 info.pos = PyInt_AsLong(item);
4030 info.gotPos = true;
4031 }
4032 }
4033 }
4034
4035 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4036 // no expected type, figure out what kind of error message to generate
4037 if ( !checkSize && !checkIdx )
4038 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4039 else if ( checkSize && !checkIdx )
4040 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4041 else if ( !checkSize && checkIdx)
4042 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4043 else
4044 // can this one happen?
4045 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4046 }
4047
4048 return info;
4049 }
4050
4051 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4052 if (!self->GetClientObject())
4053 self->SetClientObject(new wxPyOORClientData(_self));
4054 }
4055 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4056
4057 wxPyUserData* data = NULL;
4058 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4059 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4060 if ( userData && (info.window || info.sizer || info.gotSize) )
4061 data = new wxPyUserData(userData);
4062 if ( info.sizer )
4063 PyObject_SetAttrString(item,"thisown",Py_False);
4064 wxPyEndBlockThreads(blocked);
4065
4066 // Now call the real Add method if a valid item type was found
4067 if ( info.window )
4068 return self->Add(info.window, proportion, flag, border, data);
4069 else if ( info.sizer )
4070 return self->Add(info.sizer, proportion, flag, border, data);
4071 else if (info.gotSize)
4072 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4073 proportion, flag, border, data);
4074 else
4075 return NULL;
4076 }
4077 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4078
4079 wxPyUserData* data = NULL;
4080 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4081 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4082 if ( userData && (info.window || info.sizer || info.gotSize) )
4083 data = new wxPyUserData(userData);
4084 if ( info.sizer )
4085 PyObject_SetAttrString(item,"thisown",Py_False);
4086 wxPyEndBlockThreads(blocked);
4087
4088 // Now call the real Insert method if a valid item type was found
4089 if ( info.window )
4090 return self->Insert(before, info.window, proportion, flag, border, data);
4091 else if ( info.sizer )
4092 return self->Insert(before, info.sizer, proportion, flag, border, data);
4093 else if (info.gotSize)
4094 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4095 proportion, flag, border, data);
4096 else
4097 return NULL;
4098 }
4099 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4100
4101 wxPyUserData* data = NULL;
4102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4103 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4104 if ( userData && (info.window || info.sizer || info.gotSize) )
4105 data = new wxPyUserData(userData);
4106 if ( info.sizer )
4107 PyObject_SetAttrString(item,"thisown",Py_False);
4108 wxPyEndBlockThreads(blocked);
4109
4110 // Now call the real Prepend method if a valid item type was found
4111 if ( info.window )
4112 return self->Prepend(info.window, proportion, flag, border, data);
4113 else if ( info.sizer )
4114 return self->Prepend(info.sizer, proportion, flag, border, data);
4115 else if (info.gotSize)
4116 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4117 proportion, flag, border, data);
4118 else
4119 return NULL;
4120 }
4121 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4122 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4123 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4124 wxPyEndBlockThreads(blocked);
4125 if ( info.window )
4126 return self->Remove(info.window);
4127 else if ( info.sizer )
4128 return self->Remove(info.sizer);
4129 else if ( info.gotPos )
4130 return self->Remove(info.pos);
4131 else
4132 return false;
4133 }
4134 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4135 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4136 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4137 wxPyEndBlockThreads(blocked);
4138 if ( info.window )
4139 return self->Detach(info.window);
4140 else if ( info.sizer )
4141 return self->Detach(info.sizer);
4142 else if ( info.gotPos )
4143 return self->Detach(info.pos);
4144 else
4145 return false;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4150 wxPyEndBlockThreads(blocked);
4151 if ( info.window )
4152 return self->GetItem(info.window);
4153 else if ( info.sizer )
4154 return self->GetItem(info.sizer);
4155 else if ( info.gotPos )
4156 return self->GetItem(info.pos);
4157 else
4158 return NULL;
4159 }
4160 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4163 wxPyEndBlockThreads(blocked);
4164 if ( info.window )
4165 self->SetItemMinSize(info.window, size);
4166 else if ( info.sizer )
4167 self->SetItemMinSize(info.sizer, size);
4168 else if ( info.gotPos )
4169 self->SetItemMinSize(info.pos, size);
4170 }
4171 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4172 wxSizerItemList& list = self->GetChildren();
4173 return wxPy_ConvertList(&list);
4174 }
4175 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4178 wxPyEndBlockThreads(blocked);
4179 if ( info.window )
4180 return self->Show(info.window, show, recursive);
4181 else if ( info.sizer )
4182 return self->Show(info.sizer, show, recursive);
4183 else if ( info.gotPos )
4184 return self->Show(info.pos, show);
4185 else
4186 return false;
4187 }
4188 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4190 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4191 wxPyEndBlockThreads(blocked);
4192 if ( info.window )
4193 return self->IsShown(info.window);
4194 else if ( info.sizer )
4195 return self->IsShown(info.sizer);
4196 else if ( info.gotPos )
4197 return self->IsShown(info.pos);
4198 else
4199 return false;
4200 }
4201
4202 // See pyclasses.h
4203 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4204 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4205 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4206
4207
4208
4209
4210 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4211 {
4212 if (source == Py_None) {
4213 **obj = wxGBPosition(-1,-1);
4214 return true;
4215 }
4216 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4217 }
4218
4219 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4220 {
4221 if (source == Py_None) {
4222 **obj = wxGBSpan(-1,-1);
4223 return true;
4224 }
4225 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4226 }
4227
4228
4229 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4230 wxGBPosition temp, *obj = &temp;
4231 if ( other == Py_None ) return false;
4232 if ( ! wxGBPosition_helper(other, &obj) ) {
4233 PyErr_Clear();
4234 return false;
4235 }
4236 return self->operator==(*obj);
4237 }
4238 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4239 wxGBPosition temp, *obj = &temp;
4240 if ( other == Py_None ) return true;
4241 if ( ! wxGBPosition_helper(other, &obj)) {
4242 PyErr_Clear();
4243 return true;
4244 }
4245 return self->operator!=(*obj);
4246 }
4247 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4248 self->SetRow(row);
4249 self->SetCol(col);
4250 }
4251 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4252 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4253 PyObject* tup = PyTuple_New(2);
4254 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4255 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4256 wxPyEndBlockThreads(blocked);
4257 return tup;
4258 }
4259 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4260 wxGBSpan temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBSpan_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4269 wxGBSpan temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBSpan_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4278 self->SetRowspan(rowspan);
4279 self->SetColspan(colspan);
4280 }
4281 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4290 wxPyUserData* data = NULL;
4291 if ( userData ) {
4292 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4293 data = new wxPyUserData(userData);
4294 wxPyEndBlockThreads(blocked);
4295 }
4296 return new wxGBSizerItem(window, pos, span, flag, border, data);
4297 }
4298 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4299 wxPyUserData* data = NULL;
4300 if ( userData ) {
4301 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4302 data = new wxPyUserData(userData);
4303 wxPyEndBlockThreads(blocked);
4304 }
4305 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4306 }
4307 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4308 wxPyUserData* data = NULL;
4309 if ( userData ) {
4310 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4311 data = new wxPyUserData(userData);
4312 wxPyEndBlockThreads(blocked);
4313 }
4314 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4315 }
4316 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4317 int row, col;
4318 self->GetEndPos(row, col);
4319 return wxGBPosition(row, col);
4320 }
4321 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4322
4323 wxPyUserData* data = NULL;
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4326 if ( userData && (info.window || info.sizer || info.gotSize) )
4327 data = new wxPyUserData(userData);
4328 if ( info.sizer )
4329 PyObject_SetAttrString(item,"thisown",Py_False);
4330 wxPyEndBlockThreads(blocked);
4331
4332 // Now call the real Add method if a valid item type was found
4333 if ( info.window )
4334 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4335 else if ( info.sizer )
4336 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4337 else if (info.gotSize)
4338 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4339 pos, span, flag, border, data);
4340 return NULL;
4341 }
4342
4343
4344 #ifdef __cplusplus
4345 extern "C" {
4346 #endif
4347 SWIGINTERN int EmptyString_set(PyObject *) {
4348 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4349 return 1;
4350 }
4351
4352
4353 SWIGINTERN PyObject *EmptyString_get(void) {
4354 PyObject *pyobj = 0;
4355
4356 {
4357 #if wxUSE_UNICODE
4358 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4359 #else
4360 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4361 #endif
4362 }
4363 return pyobj;
4364 }
4365
4366
4367 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4368 PyObject *resultobj = 0;
4369 wxObject *arg1 = (wxObject *) 0 ;
4370 wxString result;
4371 void *argp1 = 0 ;
4372 int res1 = 0 ;
4373 PyObject *swig_obj[1] ;
4374
4375 if (!args) SWIG_fail;
4376 swig_obj[0] = args;
4377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4378 if (!SWIG_IsOK(res1)) {
4379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4380 }
4381 arg1 = reinterpret_cast< wxObject * >(argp1);
4382 {
4383 PyThreadState* __tstate = wxPyBeginAllowThreads();
4384 result = wxObject_GetClassName(arg1);
4385 wxPyEndAllowThreads(__tstate);
4386 if (PyErr_Occurred()) SWIG_fail;
4387 }
4388 {
4389 #if wxUSE_UNICODE
4390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4391 #else
4392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4393 #endif
4394 }
4395 return resultobj;
4396 fail:
4397 return NULL;
4398 }
4399
4400
4401 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4402 PyObject *resultobj = 0;
4403 wxObject *arg1 = (wxObject *) 0 ;
4404 void *argp1 = 0 ;
4405 int res1 = 0 ;
4406 PyObject *swig_obj[1] ;
4407
4408 if (!args) SWIG_fail;
4409 swig_obj[0] = args;
4410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4411 if (!SWIG_IsOK(res1)) {
4412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4413 }
4414 arg1 = reinterpret_cast< wxObject * >(argp1);
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 wxObject_Destroy(arg1);
4418 wxPyEndAllowThreads(__tstate);
4419 if (PyErr_Occurred()) SWIG_fail;
4420 }
4421 resultobj = SWIG_Py_Void();
4422 return resultobj;
4423 fail:
4424 return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4429 PyObject *obj;
4430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4431 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4432 return SWIG_Py_Void();
4433 }
4434
4435 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4436 PyObject *resultobj = 0;
4437 wxSize *arg1 = (wxSize *) 0 ;
4438 int arg2 ;
4439 void *argp1 = 0 ;
4440 int res1 = 0 ;
4441 int val2 ;
4442 int ecode2 = 0 ;
4443 PyObject *swig_obj[2] ;
4444
4445 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4447 if (!SWIG_IsOK(res1)) {
4448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4449 }
4450 arg1 = reinterpret_cast< wxSize * >(argp1);
4451 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4452 if (!SWIG_IsOK(ecode2)) {
4453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4454 }
4455 arg2 = static_cast< int >(val2);
4456 if (arg1) (arg1)->x = arg2;
4457
4458 resultobj = SWIG_Py_Void();
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int result;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 PyObject *swig_obj[1] ;
4472
4473 if (!args) SWIG_fail;
4474 swig_obj[0] = args;
4475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4476 if (!SWIG_IsOK(res1)) {
4477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4478 }
4479 arg1 = reinterpret_cast< wxSize * >(argp1);
4480 result = (int) ((arg1)->x);
4481 resultobj = SWIG_From_int(static_cast< int >(result));
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4489 PyObject *resultobj = 0;
4490 wxSize *arg1 = (wxSize *) 0 ;
4491 int arg2 ;
4492 void *argp1 = 0 ;
4493 int res1 = 0 ;
4494 int val2 ;
4495 int ecode2 = 0 ;
4496 PyObject *swig_obj[2] ;
4497
4498 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4500 if (!SWIG_IsOK(res1)) {
4501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4502 }
4503 arg1 = reinterpret_cast< wxSize * >(argp1);
4504 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4505 if (!SWIG_IsOK(ecode2)) {
4506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4507 }
4508 arg2 = static_cast< int >(val2);
4509 if (arg1) (arg1)->y = arg2;
4510
4511 resultobj = SWIG_Py_Void();
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int result;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 PyObject *swig_obj[1] ;
4525
4526 if (!args) SWIG_fail;
4527 swig_obj[0] = args;
4528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4529 if (!SWIG_IsOK(res1)) {
4530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4531 }
4532 arg1 = reinterpret_cast< wxSize * >(argp1);
4533 result = (int) ((arg1)->y);
4534 resultobj = SWIG_From_int(static_cast< int >(result));
4535 return resultobj;
4536 fail:
4537 return NULL;
4538 }
4539
4540
4541 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj = 0;
4543 int arg1 = (int) 0 ;
4544 int arg2 = (int) 0 ;
4545 wxSize *result = 0 ;
4546 int val1 ;
4547 int ecode1 = 0 ;
4548 int val2 ;
4549 int ecode2 = 0 ;
4550 PyObject * obj0 = 0 ;
4551 PyObject * obj1 = 0 ;
4552 char * kwnames[] = {
4553 (char *) "w",(char *) "h", NULL
4554 };
4555
4556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4557 if (obj0) {
4558 ecode1 = SWIG_AsVal_int(obj0, &val1);
4559 if (!SWIG_IsOK(ecode1)) {
4560 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4561 }
4562 arg1 = static_cast< int >(val1);
4563 }
4564 if (obj1) {
4565 ecode2 = SWIG_AsVal_int(obj1, &val2);
4566 if (!SWIG_IsOK(ecode2)) {
4567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4568 }
4569 arg2 = static_cast< int >(val2);
4570 }
4571 {
4572 PyThreadState* __tstate = wxPyBeginAllowThreads();
4573 result = (wxSize *)new wxSize(arg1,arg2);
4574 wxPyEndAllowThreads(__tstate);
4575 if (PyErr_Occurred()) SWIG_fail;
4576 }
4577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4578 return resultobj;
4579 fail:
4580 return NULL;
4581 }
4582
4583
4584 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 PyObject *resultobj = 0;
4586 wxSize *arg1 = (wxSize *) 0 ;
4587 void *argp1 = 0 ;
4588 int res1 = 0 ;
4589 PyObject *swig_obj[1] ;
4590
4591 if (!args) SWIG_fail;
4592 swig_obj[0] = args;
4593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 {
4599 PyThreadState* __tstate = wxPyBeginAllowThreads();
4600 delete arg1;
4601
4602 wxPyEndAllowThreads(__tstate);
4603 if (PyErr_Occurred()) SWIG_fail;
4604 }
4605 resultobj = SWIG_Py_Void();
4606 return resultobj;
4607 fail:
4608 return NULL;
4609 }
4610
4611
4612 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4613 PyObject *resultobj = 0;
4614 wxSize *arg1 = (wxSize *) 0 ;
4615 PyObject *arg2 = (PyObject *) 0 ;
4616 bool result;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject * obj0 = 0 ;
4620 PyObject * obj1 = 0 ;
4621 char * kwnames[] = {
4622 (char *) "self",(char *) "other", NULL
4623 };
4624
4625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4627 if (!SWIG_IsOK(res1)) {
4628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4629 }
4630 arg1 = reinterpret_cast< wxSize * >(argp1);
4631 arg2 = obj1;
4632 {
4633 result = (bool)wxSize___eq__(arg1,arg2);
4634 if (PyErr_Occurred()) SWIG_fail;
4635 }
4636 {
4637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4638 }
4639 return resultobj;
4640 fail:
4641 return NULL;
4642 }
4643
4644
4645 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4646 PyObject *resultobj = 0;
4647 wxSize *arg1 = (wxSize *) 0 ;
4648 PyObject *arg2 = (PyObject *) 0 ;
4649 bool result;
4650 void *argp1 = 0 ;
4651 int res1 = 0 ;
4652 PyObject * obj0 = 0 ;
4653 PyObject * obj1 = 0 ;
4654 char * kwnames[] = {
4655 (char *) "self",(char *) "other", NULL
4656 };
4657
4658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4660 if (!SWIG_IsOK(res1)) {
4661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4662 }
4663 arg1 = reinterpret_cast< wxSize * >(argp1);
4664 arg2 = obj1;
4665 {
4666 result = (bool)wxSize___ne__(arg1,arg2);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 {
4670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4671 }
4672 return resultobj;
4673 fail:
4674 return NULL;
4675 }
4676
4677
4678 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4679 PyObject *resultobj = 0;
4680 wxSize *arg1 = (wxSize *) 0 ;
4681 wxSize *arg2 = 0 ;
4682 wxSize result;
4683 void *argp1 = 0 ;
4684 int res1 = 0 ;
4685 wxSize temp2 ;
4686 PyObject * obj0 = 0 ;
4687 PyObject * obj1 = 0 ;
4688 char * kwnames[] = {
4689 (char *) "self",(char *) "sz", NULL
4690 };
4691
4692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4694 if (!SWIG_IsOK(res1)) {
4695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4696 }
4697 arg1 = reinterpret_cast< wxSize * >(argp1);
4698 {
4699 arg2 = &temp2;
4700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4701 }
4702 {
4703 PyThreadState* __tstate = wxPyBeginAllowThreads();
4704 result = (arg1)->operator +((wxSize const &)*arg2);
4705 wxPyEndAllowThreads(__tstate);
4706 if (PyErr_Occurred()) SWIG_fail;
4707 }
4708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4709 return resultobj;
4710 fail:
4711 return NULL;
4712 }
4713
4714
4715 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4716 PyObject *resultobj = 0;
4717 wxSize *arg1 = (wxSize *) 0 ;
4718 wxSize *arg2 = 0 ;
4719 wxSize result;
4720 void *argp1 = 0 ;
4721 int res1 = 0 ;
4722 wxSize temp2 ;
4723 PyObject * obj0 = 0 ;
4724 PyObject * obj1 = 0 ;
4725 char * kwnames[] = {
4726 (char *) "self",(char *) "sz", NULL
4727 };
4728
4729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4731 if (!SWIG_IsOK(res1)) {
4732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4733 }
4734 arg1 = reinterpret_cast< wxSize * >(argp1);
4735 {
4736 arg2 = &temp2;
4737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4738 }
4739 {
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = (arg1)->operator -((wxSize const &)*arg2);
4742 wxPyEndAllowThreads(__tstate);
4743 if (PyErr_Occurred()) SWIG_fail;
4744 }
4745 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4746 return resultobj;
4747 fail:
4748 return NULL;
4749 }
4750
4751
4752 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4753 PyObject *resultobj = 0;
4754 wxSize *arg1 = (wxSize *) 0 ;
4755 wxSize *arg2 = 0 ;
4756 void *argp1 = 0 ;
4757 int res1 = 0 ;
4758 wxSize temp2 ;
4759 PyObject * obj0 = 0 ;
4760 PyObject * obj1 = 0 ;
4761 char * kwnames[] = {
4762 (char *) "self",(char *) "sz", NULL
4763 };
4764
4765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4767 if (!SWIG_IsOK(res1)) {
4768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4769 }
4770 arg1 = reinterpret_cast< wxSize * >(argp1);
4771 {
4772 arg2 = &temp2;
4773 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4774 }
4775 {
4776 PyThreadState* __tstate = wxPyBeginAllowThreads();
4777 (arg1)->IncTo((wxSize const &)*arg2);
4778 wxPyEndAllowThreads(__tstate);
4779 if (PyErr_Occurred()) SWIG_fail;
4780 }
4781 resultobj = SWIG_Py_Void();
4782 return resultobj;
4783 fail:
4784 return NULL;
4785 }
4786
4787
4788 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = 0;
4790 wxSize *arg1 = (wxSize *) 0 ;
4791 wxSize *arg2 = 0 ;
4792 void *argp1 = 0 ;
4793 int res1 = 0 ;
4794 wxSize temp2 ;
4795 PyObject * obj0 = 0 ;
4796 PyObject * obj1 = 0 ;
4797 char * kwnames[] = {
4798 (char *) "self",(char *) "sz", NULL
4799 };
4800
4801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4803 if (!SWIG_IsOK(res1)) {
4804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4805 }
4806 arg1 = reinterpret_cast< wxSize * >(argp1);
4807 {
4808 arg2 = &temp2;
4809 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4810 }
4811 {
4812 PyThreadState* __tstate = wxPyBeginAllowThreads();
4813 (arg1)->DecTo((wxSize const &)*arg2);
4814 wxPyEndAllowThreads(__tstate);
4815 if (PyErr_Occurred()) SWIG_fail;
4816 }
4817 resultobj = SWIG_Py_Void();
4818 return resultobj;
4819 fail:
4820 return NULL;
4821 }
4822
4823
4824 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4825 PyObject *resultobj = 0;
4826 wxSize *arg1 = (wxSize *) 0 ;
4827 int arg2 ;
4828 int arg3 ;
4829 void *argp1 = 0 ;
4830 int res1 = 0 ;
4831 int val2 ;
4832 int ecode2 = 0 ;
4833 int val3 ;
4834 int ecode3 = 0 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 PyObject * obj2 = 0 ;
4838 char * kwnames[] = {
4839 (char *) "self",(char *) "w",(char *) "h", NULL
4840 };
4841
4842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4846 }
4847 arg1 = reinterpret_cast< wxSize * >(argp1);
4848 ecode2 = SWIG_AsVal_int(obj1, &val2);
4849 if (!SWIG_IsOK(ecode2)) {
4850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4851 }
4852 arg2 = static_cast< int >(val2);
4853 ecode3 = SWIG_AsVal_int(obj2, &val3);
4854 if (!SWIG_IsOK(ecode3)) {
4855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4856 }
4857 arg3 = static_cast< int >(val3);
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 (arg1)->Set(arg2,arg3);
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj = 0;
4873 wxSize *arg1 = (wxSize *) 0 ;
4874 int arg2 ;
4875 void *argp1 = 0 ;
4876 int res1 = 0 ;
4877 int val2 ;
4878 int ecode2 = 0 ;
4879 PyObject * obj0 = 0 ;
4880 PyObject * obj1 = 0 ;
4881 char * kwnames[] = {
4882 (char *) "self",(char *) "w", NULL
4883 };
4884
4885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4887 if (!SWIG_IsOK(res1)) {
4888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4889 }
4890 arg1 = reinterpret_cast< wxSize * >(argp1);
4891 ecode2 = SWIG_AsVal_int(obj1, &val2);
4892 if (!SWIG_IsOK(ecode2)) {
4893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4894 }
4895 arg2 = static_cast< int >(val2);
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 (arg1)->SetWidth(arg2);
4899 wxPyEndAllowThreads(__tstate);
4900 if (PyErr_Occurred()) SWIG_fail;
4901 }
4902 resultobj = SWIG_Py_Void();
4903 return resultobj;
4904 fail:
4905 return NULL;
4906 }
4907
4908
4909 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4910 PyObject *resultobj = 0;
4911 wxSize *arg1 = (wxSize *) 0 ;
4912 int arg2 ;
4913 void *argp1 = 0 ;
4914 int res1 = 0 ;
4915 int val2 ;
4916 int ecode2 = 0 ;
4917 PyObject * obj0 = 0 ;
4918 PyObject * obj1 = 0 ;
4919 char * kwnames[] = {
4920 (char *) "self",(char *) "h", NULL
4921 };
4922
4923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4925 if (!SWIG_IsOK(res1)) {
4926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4927 }
4928 arg1 = reinterpret_cast< wxSize * >(argp1);
4929 ecode2 = SWIG_AsVal_int(obj1, &val2);
4930 if (!SWIG_IsOK(ecode2)) {
4931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4932 }
4933 arg2 = static_cast< int >(val2);
4934 {
4935 PyThreadState* __tstate = wxPyBeginAllowThreads();
4936 (arg1)->SetHeight(arg2);
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 resultobj = SWIG_Py_Void();
4941 return resultobj;
4942 fail:
4943 return NULL;
4944 }
4945
4946
4947 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4948 PyObject *resultobj = 0;
4949 wxSize *arg1 = (wxSize *) 0 ;
4950 int result;
4951 void *argp1 = 0 ;
4952 int res1 = 0 ;
4953 PyObject *swig_obj[1] ;
4954
4955 if (!args) SWIG_fail;
4956 swig_obj[0] = args;
4957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4958 if (!SWIG_IsOK(res1)) {
4959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4960 }
4961 arg1 = reinterpret_cast< wxSize * >(argp1);
4962 {
4963 PyThreadState* __tstate = wxPyBeginAllowThreads();
4964 result = (int)((wxSize const *)arg1)->GetWidth();
4965 wxPyEndAllowThreads(__tstate);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_From_int(static_cast< int >(result));
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 int result;
4979 void *argp1 = 0 ;
4980 int res1 = 0 ;
4981 PyObject *swig_obj[1] ;
4982
4983 if (!args) SWIG_fail;
4984 swig_obj[0] = args;
4985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4986 if (!SWIG_IsOK(res1)) {
4987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4988 }
4989 arg1 = reinterpret_cast< wxSize * >(argp1);
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 result = (int)((wxSize const *)arg1)->GetHeight();
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 resultobj = SWIG_From_int(static_cast< int >(result));
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5004 PyObject *resultobj = 0;
5005 wxSize *arg1 = (wxSize *) 0 ;
5006 bool result;
5007 void *argp1 = 0 ;
5008 int res1 = 0 ;
5009 PyObject *swig_obj[1] ;
5010
5011 if (!args) SWIG_fail;
5012 swig_obj[0] = args;
5013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5014 if (!SWIG_IsOK(res1)) {
5015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5016 }
5017 arg1 = reinterpret_cast< wxSize * >(argp1);
5018 {
5019 PyThreadState* __tstate = wxPyBeginAllowThreads();
5020 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5021 wxPyEndAllowThreads(__tstate);
5022 if (PyErr_Occurred()) SWIG_fail;
5023 }
5024 {
5025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5026 }
5027 return resultobj;
5028 fail:
5029 return NULL;
5030 }
5031
5032
5033 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5034 PyObject *resultobj = 0;
5035 wxSize *arg1 = (wxSize *) 0 ;
5036 wxSize *arg2 = 0 ;
5037 void *argp1 = 0 ;
5038 int res1 = 0 ;
5039 wxSize temp2 ;
5040 PyObject * obj0 = 0 ;
5041 PyObject * obj1 = 0 ;
5042 char * kwnames[] = {
5043 (char *) "self",(char *) "size", NULL
5044 };
5045
5046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5048 if (!SWIG_IsOK(res1)) {
5049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5050 }
5051 arg1 = reinterpret_cast< wxSize * >(argp1);
5052 {
5053 arg2 = &temp2;
5054 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5055 }
5056 {
5057 PyThreadState* __tstate = wxPyBeginAllowThreads();
5058 (arg1)->SetDefaults((wxSize const &)*arg2);
5059 wxPyEndAllowThreads(__tstate);
5060 if (PyErr_Occurred()) SWIG_fail;
5061 }
5062 resultobj = SWIG_Py_Void();
5063 return resultobj;
5064 fail:
5065 return NULL;
5066 }
5067
5068
5069 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5070 PyObject *resultobj = 0;
5071 wxSize *arg1 = (wxSize *) 0 ;
5072 PyObject *result = 0 ;
5073 void *argp1 = 0 ;
5074 int res1 = 0 ;
5075 PyObject *swig_obj[1] ;
5076
5077 if (!args) SWIG_fail;
5078 swig_obj[0] = args;
5079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5080 if (!SWIG_IsOK(res1)) {
5081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5082 }
5083 arg1 = reinterpret_cast< wxSize * >(argp1);
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (PyObject *)wxSize_Get(arg1);
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 resultobj = result;
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5098 PyObject *obj;
5099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5100 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5101 return SWIG_Py_Void();
5102 }
5103
5104 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5105 return SWIG_Python_InitShadowInstance(args);
5106 }
5107
5108 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5109 PyObject *resultobj = 0;
5110 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5111 double arg2 ;
5112 void *argp1 = 0 ;
5113 int res1 = 0 ;
5114 double val2 ;
5115 int ecode2 = 0 ;
5116 PyObject *swig_obj[2] ;
5117
5118 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5120 if (!SWIG_IsOK(res1)) {
5121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5122 }
5123 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5124 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5125 if (!SWIG_IsOK(ecode2)) {
5126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5127 }
5128 arg2 = static_cast< double >(val2);
5129 if (arg1) (arg1)->x = arg2;
5130
5131 resultobj = SWIG_Py_Void();
5132 return resultobj;
5133 fail:
5134 return NULL;
5135 }
5136
5137
5138 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5139 PyObject *resultobj = 0;
5140 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5141 double result;
5142 void *argp1 = 0 ;
5143 int res1 = 0 ;
5144 PyObject *swig_obj[1] ;
5145
5146 if (!args) SWIG_fail;
5147 swig_obj[0] = args;
5148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5149 if (!SWIG_IsOK(res1)) {
5150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5151 }
5152 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5153 result = (double) ((arg1)->x);
5154 resultobj = SWIG_From_double(static_cast< double >(result));
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5164 double arg2 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 double val2 ;
5168 int ecode2 = 0 ;
5169 PyObject *swig_obj[2] ;
5170
5171 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5173 if (!SWIG_IsOK(res1)) {
5174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5175 }
5176 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5177 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5178 if (!SWIG_IsOK(ecode2)) {
5179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5180 }
5181 arg2 = static_cast< double >(val2);
5182 if (arg1) (arg1)->y = arg2;
5183
5184 resultobj = SWIG_Py_Void();
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5192 PyObject *resultobj = 0;
5193 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5194 double result;
5195 void *argp1 = 0 ;
5196 int res1 = 0 ;
5197 PyObject *swig_obj[1] ;
5198
5199 if (!args) SWIG_fail;
5200 swig_obj[0] = args;
5201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5202 if (!SWIG_IsOK(res1)) {
5203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5204 }
5205 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5206 result = (double) ((arg1)->y);
5207 resultobj = SWIG_From_double(static_cast< double >(result));
5208 return resultobj;
5209 fail:
5210 return NULL;
5211 }
5212
5213
5214 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5215 PyObject *resultobj = 0;
5216 double arg1 = (double) 0.0 ;
5217 double arg2 = (double) 0.0 ;
5218 wxRealPoint *result = 0 ;
5219 double val1 ;
5220 int ecode1 = 0 ;
5221 double val2 ;
5222 int ecode2 = 0 ;
5223 PyObject * obj0 = 0 ;
5224 PyObject * obj1 = 0 ;
5225 char * kwnames[] = {
5226 (char *) "x",(char *) "y", NULL
5227 };
5228
5229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5230 if (obj0) {
5231 ecode1 = SWIG_AsVal_double(obj0, &val1);
5232 if (!SWIG_IsOK(ecode1)) {
5233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5234 }
5235 arg1 = static_cast< double >(val1);
5236 }
5237 if (obj1) {
5238 ecode2 = SWIG_AsVal_double(obj1, &val2);
5239 if (!SWIG_IsOK(ecode2)) {
5240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5241 }
5242 arg2 = static_cast< double >(val2);
5243 }
5244 {
5245 PyThreadState* __tstate = wxPyBeginAllowThreads();
5246 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5247 wxPyEndAllowThreads(__tstate);
5248 if (PyErr_Occurred()) SWIG_fail;
5249 }
5250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5251 return resultobj;
5252 fail:
5253 return NULL;
5254 }
5255
5256
5257 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5258 PyObject *resultobj = 0;
5259 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5260 void *argp1 = 0 ;
5261 int res1 = 0 ;
5262 PyObject *swig_obj[1] ;
5263
5264 if (!args) SWIG_fail;
5265 swig_obj[0] = args;
5266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5267 if (!SWIG_IsOK(res1)) {
5268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5269 }
5270 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 delete arg1;
5274
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 resultobj = SWIG_Py_Void();
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5286 PyObject *resultobj = 0;
5287 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5288 PyObject *arg2 = (PyObject *) 0 ;
5289 bool result;
5290 void *argp1 = 0 ;
5291 int res1 = 0 ;
5292 PyObject * obj0 = 0 ;
5293 PyObject * obj1 = 0 ;
5294 char * kwnames[] = {
5295 (char *) "self",(char *) "other", NULL
5296 };
5297
5298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5300 if (!SWIG_IsOK(res1)) {
5301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5302 }
5303 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5304 arg2 = obj1;
5305 {
5306 result = (bool)wxRealPoint___eq__(arg1,arg2);
5307 if (PyErr_Occurred()) SWIG_fail;
5308 }
5309 {
5310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5311 }
5312 return resultobj;
5313 fail:
5314 return NULL;
5315 }
5316
5317
5318 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5319 PyObject *resultobj = 0;
5320 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5321 PyObject *arg2 = (PyObject *) 0 ;
5322 bool result;
5323 void *argp1 = 0 ;
5324 int res1 = 0 ;
5325 PyObject * obj0 = 0 ;
5326 PyObject * obj1 = 0 ;
5327 char * kwnames[] = {
5328 (char *) "self",(char *) "other", NULL
5329 };
5330
5331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5333 if (!SWIG_IsOK(res1)) {
5334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5335 }
5336 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5337 arg2 = obj1;
5338 {
5339 result = (bool)wxRealPoint___ne__(arg1,arg2);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 {
5343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5344 }
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5352 PyObject *resultobj = 0;
5353 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5354 wxRealPoint *arg2 = 0 ;
5355 wxRealPoint result;
5356 void *argp1 = 0 ;
5357 int res1 = 0 ;
5358 wxRealPoint temp2 ;
5359 PyObject * obj0 = 0 ;
5360 PyObject * obj1 = 0 ;
5361 char * kwnames[] = {
5362 (char *) "self",(char *) "pt", NULL
5363 };
5364
5365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5367 if (!SWIG_IsOK(res1)) {
5368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5369 }
5370 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5371 {
5372 arg2 = &temp2;
5373 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5374 }
5375 {
5376 PyThreadState* __tstate = wxPyBeginAllowThreads();
5377 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5378 wxPyEndAllowThreads(__tstate);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5389 PyObject *resultobj = 0;
5390 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5391 wxRealPoint *arg2 = 0 ;
5392 wxRealPoint result;
5393 void *argp1 = 0 ;
5394 int res1 = 0 ;
5395 wxRealPoint temp2 ;
5396 PyObject * obj0 = 0 ;
5397 PyObject * obj1 = 0 ;
5398 char * kwnames[] = {
5399 (char *) "self",(char *) "pt", NULL
5400 };
5401
5402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5404 if (!SWIG_IsOK(res1)) {
5405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5406 }
5407 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5408 {
5409 arg2 = &temp2;
5410 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5411 }
5412 {
5413 PyThreadState* __tstate = wxPyBeginAllowThreads();
5414 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5415 wxPyEndAllowThreads(__tstate);
5416 if (PyErr_Occurred()) SWIG_fail;
5417 }
5418 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj = 0;
5427 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5428 double arg2 ;
5429 double arg3 ;
5430 void *argp1 = 0 ;
5431 int res1 = 0 ;
5432 double val2 ;
5433 int ecode2 = 0 ;
5434 double val3 ;
5435 int ecode3 = 0 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 PyObject * obj2 = 0 ;
5439 char * kwnames[] = {
5440 (char *) "self",(char *) "x",(char *) "y", NULL
5441 };
5442
5443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5445 if (!SWIG_IsOK(res1)) {
5446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5447 }
5448 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5449 ecode2 = SWIG_AsVal_double(obj1, &val2);
5450 if (!SWIG_IsOK(ecode2)) {
5451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5452 }
5453 arg2 = static_cast< double >(val2);
5454 ecode3 = SWIG_AsVal_double(obj2, &val3);
5455 if (!SWIG_IsOK(ecode3)) {
5456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5457 }
5458 arg3 = static_cast< double >(val3);
5459 {
5460 PyThreadState* __tstate = wxPyBeginAllowThreads();
5461 wxRealPoint_Set(arg1,arg2,arg3);
5462 wxPyEndAllowThreads(__tstate);
5463 if (PyErr_Occurred()) SWIG_fail;
5464 }
5465 resultobj = SWIG_Py_Void();
5466 return resultobj;
5467 fail:
5468 return NULL;
5469 }
5470
5471
5472 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5473 PyObject *resultobj = 0;
5474 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5475 PyObject *result = 0 ;
5476 void *argp1 = 0 ;
5477 int res1 = 0 ;
5478 PyObject *swig_obj[1] ;
5479
5480 if (!args) SWIG_fail;
5481 swig_obj[0] = args;
5482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5483 if (!SWIG_IsOK(res1)) {
5484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5485 }
5486 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5487 {
5488 PyThreadState* __tstate = wxPyBeginAllowThreads();
5489 result = (PyObject *)wxRealPoint_Get(arg1);
5490 wxPyEndAllowThreads(__tstate);
5491 if (PyErr_Occurred()) SWIG_fail;
5492 }
5493 resultobj = result;
5494 return resultobj;
5495 fail:
5496 return NULL;
5497 }
5498
5499
5500 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5501 PyObject *obj;
5502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5503 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5504 return SWIG_Py_Void();
5505 }
5506
5507 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5508 return SWIG_Python_InitShadowInstance(args);
5509 }
5510
5511 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5512 PyObject *resultobj = 0;
5513 wxPoint *arg1 = (wxPoint *) 0 ;
5514 int arg2 ;
5515 void *argp1 = 0 ;
5516 int res1 = 0 ;
5517 int val2 ;
5518 int ecode2 = 0 ;
5519 PyObject *swig_obj[2] ;
5520
5521 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5523 if (!SWIG_IsOK(res1)) {
5524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5525 }
5526 arg1 = reinterpret_cast< wxPoint * >(argp1);
5527 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5528 if (!SWIG_IsOK(ecode2)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5530 }
5531 arg2 = static_cast< int >(val2);
5532 if (arg1) (arg1)->x = arg2;
5533
5534 resultobj = SWIG_Py_Void();
5535 return resultobj;
5536 fail:
5537 return NULL;
5538 }
5539
5540
5541 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5542 PyObject *resultobj = 0;
5543 wxPoint *arg1 = (wxPoint *) 0 ;
5544 int result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 PyObject *swig_obj[1] ;
5548
5549 if (!args) SWIG_fail;
5550 swig_obj[0] = args;
5551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5552 if (!SWIG_IsOK(res1)) {
5553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5554 }
5555 arg1 = reinterpret_cast< wxPoint * >(argp1);
5556 result = (int) ((arg1)->x);
5557 resultobj = SWIG_From_int(static_cast< int >(result));
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxPoint *arg1 = (wxPoint *) 0 ;
5567 int arg2 ;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 int val2 ;
5571 int ecode2 = 0 ;
5572 PyObject *swig_obj[2] ;
5573
5574 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5576 if (!SWIG_IsOK(res1)) {
5577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5578 }
5579 arg1 = reinterpret_cast< wxPoint * >(argp1);
5580 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5581 if (!SWIG_IsOK(ecode2)) {
5582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5583 }
5584 arg2 = static_cast< int >(val2);
5585 if (arg1) (arg1)->y = arg2;
5586
5587 resultobj = SWIG_Py_Void();
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5595 PyObject *resultobj = 0;
5596 wxPoint *arg1 = (wxPoint *) 0 ;
5597 int result;
5598 void *argp1 = 0 ;
5599 int res1 = 0 ;
5600 PyObject *swig_obj[1] ;
5601
5602 if (!args) SWIG_fail;
5603 swig_obj[0] = args;
5604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5605 if (!SWIG_IsOK(res1)) {
5606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5607 }
5608 arg1 = reinterpret_cast< wxPoint * >(argp1);
5609 result = (int) ((arg1)->y);
5610 resultobj = SWIG_From_int(static_cast< int >(result));
5611 return resultobj;
5612 fail:
5613 return NULL;
5614 }
5615
5616
5617 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5618 PyObject *resultobj = 0;
5619 int arg1 = (int) 0 ;
5620 int arg2 = (int) 0 ;
5621 wxPoint *result = 0 ;
5622 int val1 ;
5623 int ecode1 = 0 ;
5624 int val2 ;
5625 int ecode2 = 0 ;
5626 PyObject * obj0 = 0 ;
5627 PyObject * obj1 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "x",(char *) "y", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5633 if (obj0) {
5634 ecode1 = SWIG_AsVal_int(obj0, &val1);
5635 if (!SWIG_IsOK(ecode1)) {
5636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5637 }
5638 arg1 = static_cast< int >(val1);
5639 }
5640 if (obj1) {
5641 ecode2 = SWIG_AsVal_int(obj1, &val2);
5642 if (!SWIG_IsOK(ecode2)) {
5643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5644 }
5645 arg2 = static_cast< int >(val2);
5646 }
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 result = (wxPoint *)new wxPoint(arg1,arg2);
5650 wxPyEndAllowThreads(__tstate);
5651 if (PyErr_Occurred()) SWIG_fail;
5652 }
5653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5661 PyObject *resultobj = 0;
5662 wxPoint *arg1 = (wxPoint *) 0 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 PyObject *swig_obj[1] ;
5666
5667 if (!args) SWIG_fail;
5668 swig_obj[0] = args;
5669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5670 if (!SWIG_IsOK(res1)) {
5671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5672 }
5673 arg1 = reinterpret_cast< wxPoint * >(argp1);
5674 {
5675 PyThreadState* __tstate = wxPyBeginAllowThreads();
5676 delete arg1;
5677
5678 wxPyEndAllowThreads(__tstate);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 resultobj = SWIG_Py_Void();
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5689 PyObject *resultobj = 0;
5690 wxPoint *arg1 = (wxPoint *) 0 ;
5691 PyObject *arg2 = (PyObject *) 0 ;
5692 bool result;
5693 void *argp1 = 0 ;
5694 int res1 = 0 ;
5695 PyObject * obj0 = 0 ;
5696 PyObject * obj1 = 0 ;
5697 char * kwnames[] = {
5698 (char *) "self",(char *) "other", NULL
5699 };
5700
5701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5703 if (!SWIG_IsOK(res1)) {
5704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5705 }
5706 arg1 = reinterpret_cast< wxPoint * >(argp1);
5707 arg2 = obj1;
5708 {
5709 result = (bool)wxPoint___eq__(arg1,arg2);
5710 if (PyErr_Occurred()) SWIG_fail;
5711 }
5712 {
5713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5714 }
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj = 0;
5723 wxPoint *arg1 = (wxPoint *) 0 ;
5724 PyObject *arg2 = (PyObject *) 0 ;
5725 bool result;
5726 void *argp1 = 0 ;
5727 int res1 = 0 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "other", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxPoint * >(argp1);
5740 arg2 = obj1;
5741 {
5742 result = (bool)wxPoint___ne__(arg1,arg2);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 {
5746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5747 }
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj = 0;
5756 wxPoint *arg1 = (wxPoint *) 0 ;
5757 wxPoint *arg2 = 0 ;
5758 wxPoint result;
5759 void *argp1 = 0 ;
5760 int res1 = 0 ;
5761 wxPoint temp2 ;
5762 PyObject * obj0 = 0 ;
5763 PyObject * obj1 = 0 ;
5764 char * kwnames[] = {
5765 (char *) "self",(char *) "pt", NULL
5766 };
5767
5768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5770 if (!SWIG_IsOK(res1)) {
5771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5772 }
5773 arg1 = reinterpret_cast< wxPoint * >(argp1);
5774 {
5775 arg2 = &temp2;
5776 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5777 }
5778 {
5779 PyThreadState* __tstate = wxPyBeginAllowThreads();
5780 result = (arg1)->operator +((wxPoint const &)*arg2);
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj = 0;
5793 wxPoint *arg1 = (wxPoint *) 0 ;
5794 wxPoint *arg2 = 0 ;
5795 wxPoint result;
5796 void *argp1 = 0 ;
5797 int res1 = 0 ;
5798 wxPoint temp2 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "self",(char *) "pt", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5807 if (!SWIG_IsOK(res1)) {
5808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5809 }
5810 arg1 = reinterpret_cast< wxPoint * >(argp1);
5811 {
5812 arg2 = &temp2;
5813 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5814 }
5815 {
5816 PyThreadState* __tstate = wxPyBeginAllowThreads();
5817 result = (arg1)->operator -((wxPoint const &)*arg2);
5818 wxPyEndAllowThreads(__tstate);
5819 if (PyErr_Occurred()) SWIG_fail;
5820 }
5821 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5829 PyObject *resultobj = 0;
5830 wxPoint *arg1 = (wxPoint *) 0 ;
5831 wxPoint *arg2 = 0 ;
5832 wxPoint *result = 0 ;
5833 void *argp1 = 0 ;
5834 int res1 = 0 ;
5835 wxPoint temp2 ;
5836 PyObject * obj0 = 0 ;
5837 PyObject * obj1 = 0 ;
5838 char * kwnames[] = {
5839 (char *) "self",(char *) "pt", NULL
5840 };
5841
5842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5844 if (!SWIG_IsOK(res1)) {
5845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5846 }
5847 arg1 = reinterpret_cast< wxPoint * >(argp1);
5848 {
5849 arg2 = &temp2;
5850 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5851 }
5852 {
5853 PyThreadState* __tstate = wxPyBeginAllowThreads();
5854 {
5855 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5856 result = (wxPoint *) &_result_ref;
5857 }
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxPoint *arg1 = (wxPoint *) 0 ;
5871 wxPoint *arg2 = 0 ;
5872 wxPoint *result = 0 ;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char * kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5884 if (!SWIG_IsOK(res1)) {
5885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5886 }
5887 arg1 = reinterpret_cast< wxPoint * >(argp1);
5888 {
5889 arg2 = &temp2;
5890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5891 }
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 {
5895 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5896 result = (wxPoint *) &_result_ref;
5897 }
5898 wxPyEndAllowThreads(__tstate);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5902 return resultobj;
5903 fail:
5904 return NULL;
5905 }
5906
5907
5908 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5909 PyObject *resultobj = 0;
5910 wxPoint *arg1 = (wxPoint *) 0 ;
5911 long arg2 ;
5912 long arg3 ;
5913 void *argp1 = 0 ;
5914 int res1 = 0 ;
5915 long val2 ;
5916 int ecode2 = 0 ;
5917 long val3 ;
5918 int ecode3 = 0 ;
5919 PyObject * obj0 = 0 ;
5920 PyObject * obj1 = 0 ;
5921 PyObject * obj2 = 0 ;
5922 char * kwnames[] = {
5923 (char *) "self",(char *) "x",(char *) "y", NULL
5924 };
5925
5926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5930 }
5931 arg1 = reinterpret_cast< wxPoint * >(argp1);
5932 ecode2 = SWIG_AsVal_long(obj1, &val2);
5933 if (!SWIG_IsOK(ecode2)) {
5934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5935 }
5936 arg2 = static_cast< long >(val2);
5937 ecode3 = SWIG_AsVal_long(obj2, &val3);
5938 if (!SWIG_IsOK(ecode3)) {
5939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5940 }
5941 arg3 = static_cast< long >(val3);
5942 {
5943 PyThreadState* __tstate = wxPyBeginAllowThreads();
5944 wxPoint_Set(arg1,arg2,arg3);
5945 wxPyEndAllowThreads(__tstate);
5946 if (PyErr_Occurred()) SWIG_fail;
5947 }
5948 resultobj = SWIG_Py_Void();
5949 return resultobj;
5950 fail:
5951 return NULL;
5952 }
5953
5954
5955 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5956 PyObject *resultobj = 0;
5957 wxPoint *arg1 = (wxPoint *) 0 ;
5958 PyObject *result = 0 ;
5959 void *argp1 = 0 ;
5960 int res1 = 0 ;
5961 PyObject *swig_obj[1] ;
5962
5963 if (!args) SWIG_fail;
5964 swig_obj[0] = args;
5965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5966 if (!SWIG_IsOK(res1)) {
5967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5968 }
5969 arg1 = reinterpret_cast< wxPoint * >(argp1);
5970 {
5971 PyThreadState* __tstate = wxPyBeginAllowThreads();
5972 result = (PyObject *)wxPoint_Get(arg1);
5973 wxPyEndAllowThreads(__tstate);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = result;
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5984 PyObject *obj;
5985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5987 return SWIG_Py_Void();
5988 }
5989
5990 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5991 return SWIG_Python_InitShadowInstance(args);
5992 }
5993
5994 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = 0;
5996 int arg1 = (int) 0 ;
5997 int arg2 = (int) 0 ;
5998 int arg3 = (int) 0 ;
5999 int arg4 = (int) 0 ;
6000 wxRect *result = 0 ;
6001 int val1 ;
6002 int ecode1 = 0 ;
6003 int val2 ;
6004 int ecode2 = 0 ;
6005 int val3 ;
6006 int ecode3 = 0 ;
6007 int val4 ;
6008 int ecode4 = 0 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 PyObject * obj2 = 0 ;
6012 PyObject * obj3 = 0 ;
6013 char * kwnames[] = {
6014 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6015 };
6016
6017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6018 if (obj0) {
6019 ecode1 = SWIG_AsVal_int(obj0, &val1);
6020 if (!SWIG_IsOK(ecode1)) {
6021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6022 }
6023 arg1 = static_cast< int >(val1);
6024 }
6025 if (obj1) {
6026 ecode2 = SWIG_AsVal_int(obj1, &val2);
6027 if (!SWIG_IsOK(ecode2)) {
6028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6029 }
6030 arg2 = static_cast< int >(val2);
6031 }
6032 if (obj2) {
6033 ecode3 = SWIG_AsVal_int(obj2, &val3);
6034 if (!SWIG_IsOK(ecode3)) {
6035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6036 }
6037 arg3 = static_cast< int >(val3);
6038 }
6039 if (obj3) {
6040 ecode4 = SWIG_AsVal_int(obj3, &val4);
6041 if (!SWIG_IsOK(ecode4)) {
6042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6043 }
6044 arg4 = static_cast< int >(val4);
6045 }
6046 {
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6049 wxPyEndAllowThreads(__tstate);
6050 if (PyErr_Occurred()) SWIG_fail;
6051 }
6052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6053 return resultobj;
6054 fail:
6055 return NULL;
6056 }
6057
6058
6059 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6060 PyObject *resultobj = 0;
6061 wxPoint *arg1 = 0 ;
6062 wxPoint *arg2 = 0 ;
6063 wxRect *result = 0 ;
6064 wxPoint temp1 ;
6065 wxPoint temp2 ;
6066 PyObject * obj0 = 0 ;
6067 PyObject * obj1 = 0 ;
6068 char * kwnames[] = {
6069 (char *) "topLeft",(char *) "bottomRight", NULL
6070 };
6071
6072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6073 {
6074 arg1 = &temp1;
6075 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6076 }
6077 {
6078 arg2 = &temp2;
6079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6084 wxPyEndAllowThreads(__tstate);
6085 if (PyErr_Occurred()) SWIG_fail;
6086 }
6087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj = 0;
6096 wxPoint *arg1 = 0 ;
6097 wxSize *arg2 = 0 ;
6098 wxRect *result = 0 ;
6099 wxPoint temp1 ;
6100 wxSize temp2 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 char * kwnames[] = {
6104 (char *) "pos",(char *) "size", NULL
6105 };
6106
6107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6108 {
6109 arg1 = &temp1;
6110 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6111 }
6112 {
6113 arg2 = &temp2;
6114 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6115 }
6116 {
6117 PyThreadState* __tstate = wxPyBeginAllowThreads();
6118 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6119 wxPyEndAllowThreads(__tstate);
6120 if (PyErr_Occurred()) SWIG_fail;
6121 }
6122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj = 0;
6131 wxSize *arg1 = 0 ;
6132 wxRect *result = 0 ;
6133 wxSize temp1 ;
6134 PyObject * obj0 = 0 ;
6135 char * kwnames[] = {
6136 (char *) "size", NULL
6137 };
6138
6139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6140 {
6141 arg1 = &temp1;
6142 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6143 }
6144 {
6145 PyThreadState* __tstate = wxPyBeginAllowThreads();
6146 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6147 wxPyEndAllowThreads(__tstate);
6148 if (PyErr_Occurred()) SWIG_fail;
6149 }
6150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6151 return resultobj;
6152 fail:
6153 return NULL;
6154 }
6155
6156
6157 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6158 PyObject *resultobj = 0;
6159 wxRect *arg1 = (wxRect *) 0 ;
6160 void *argp1 = 0 ;
6161 int res1 = 0 ;
6162 PyObject *swig_obj[1] ;
6163
6164 if (!args) SWIG_fail;
6165 swig_obj[0] = args;
6166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6167 if (!SWIG_IsOK(res1)) {
6168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6169 }
6170 arg1 = reinterpret_cast< wxRect * >(argp1);
6171 {
6172 PyThreadState* __tstate = wxPyBeginAllowThreads();
6173 delete arg1;
6174
6175 wxPyEndAllowThreads(__tstate);
6176 if (PyErr_Occurred()) SWIG_fail;
6177 }
6178 resultobj = SWIG_Py_Void();
6179 return resultobj;
6180 fail:
6181 return NULL;
6182 }
6183
6184
6185 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6186 PyObject *resultobj = 0;
6187 wxRect *arg1 = (wxRect *) 0 ;
6188 int result;
6189 void *argp1 = 0 ;
6190 int res1 = 0 ;
6191 PyObject *swig_obj[1] ;
6192
6193 if (!args) SWIG_fail;
6194 swig_obj[0] = args;
6195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6196 if (!SWIG_IsOK(res1)) {
6197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6198 }
6199 arg1 = reinterpret_cast< wxRect * >(argp1);
6200 {
6201 PyThreadState* __tstate = wxPyBeginAllowThreads();
6202 result = (int)((wxRect const *)arg1)->GetX();
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 resultobj = SWIG_From_int(static_cast< int >(result));
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj = 0;
6215 wxRect *arg1 = (wxRect *) 0 ;
6216 int arg2 ;
6217 void *argp1 = 0 ;
6218 int res1 = 0 ;
6219 int val2 ;
6220 int ecode2 = 0 ;
6221 PyObject * obj0 = 0 ;
6222 PyObject * obj1 = 0 ;
6223 char * kwnames[] = {
6224 (char *) "self",(char *) "x", NULL
6225 };
6226
6227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6229 if (!SWIG_IsOK(res1)) {
6230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6231 }
6232 arg1 = reinterpret_cast< wxRect * >(argp1);
6233 ecode2 = SWIG_AsVal_int(obj1, &val2);
6234 if (!SWIG_IsOK(ecode2)) {
6235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6236 }
6237 arg2 = static_cast< int >(val2);
6238 {
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 (arg1)->SetX(arg2);
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 resultobj = SWIG_Py_Void();
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6252 PyObject *resultobj = 0;
6253 wxRect *arg1 = (wxRect *) 0 ;
6254 int result;
6255 void *argp1 = 0 ;
6256 int res1 = 0 ;
6257 PyObject *swig_obj[1] ;
6258
6259 if (!args) SWIG_fail;
6260 swig_obj[0] = args;
6261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6262 if (!SWIG_IsOK(res1)) {
6263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6264 }
6265 arg1 = reinterpret_cast< wxRect * >(argp1);
6266 {
6267 PyThreadState* __tstate = wxPyBeginAllowThreads();
6268 result = (int)(arg1)->GetY();
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 resultobj = SWIG_From_int(static_cast< int >(result));
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6280 PyObject *resultobj = 0;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int arg2 ;
6283 void *argp1 = 0 ;
6284 int res1 = 0 ;
6285 int val2 ;
6286 int ecode2 = 0 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char * kwnames[] = {
6290 (char *) "self",(char *) "y", NULL
6291 };
6292
6293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6295 if (!SWIG_IsOK(res1)) {
6296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6297 }
6298 arg1 = reinterpret_cast< wxRect * >(argp1);
6299 ecode2 = SWIG_AsVal_int(obj1, &val2);
6300 if (!SWIG_IsOK(ecode2)) {
6301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6302 }
6303 arg2 = static_cast< int >(val2);
6304 {
6305 PyThreadState* __tstate = wxPyBeginAllowThreads();
6306 (arg1)->SetY(arg2);
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 resultobj = SWIG_Py_Void();
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6318 PyObject *resultobj = 0;
6319 wxRect *arg1 = (wxRect *) 0 ;
6320 int result;
6321 void *argp1 = 0 ;
6322 int res1 = 0 ;
6323 PyObject *swig_obj[1] ;
6324
6325 if (!args) SWIG_fail;
6326 swig_obj[0] = args;
6327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6328 if (!SWIG_IsOK(res1)) {
6329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6330 }
6331 arg1 = reinterpret_cast< wxRect * >(argp1);
6332 {
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 result = (int)((wxRect const *)arg1)->GetWidth();
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 resultobj = SWIG_From_int(static_cast< int >(result));
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6346 PyObject *resultobj = 0;
6347 wxRect *arg1 = (wxRect *) 0 ;
6348 int arg2 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 int val2 ;
6352 int ecode2 = 0 ;
6353 PyObject * obj0 = 0 ;
6354 PyObject * obj1 = 0 ;
6355 char * kwnames[] = {
6356 (char *) "self",(char *) "w", NULL
6357 };
6358
6359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6361 if (!SWIG_IsOK(res1)) {
6362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6363 }
6364 arg1 = reinterpret_cast< wxRect * >(argp1);
6365 ecode2 = SWIG_AsVal_int(obj1, &val2);
6366 if (!SWIG_IsOK(ecode2)) {
6367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6368 }
6369 arg2 = static_cast< int >(val2);
6370 {
6371 PyThreadState* __tstate = wxPyBeginAllowThreads();
6372 (arg1)->SetWidth(arg2);
6373 wxPyEndAllowThreads(__tstate);
6374 if (PyErr_Occurred()) SWIG_fail;
6375 }
6376 resultobj = SWIG_Py_Void();
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6384 PyObject *resultobj = 0;
6385 wxRect *arg1 = (wxRect *) 0 ;
6386 int result;
6387 void *argp1 = 0 ;
6388 int res1 = 0 ;
6389 PyObject *swig_obj[1] ;
6390
6391 if (!args) SWIG_fail;
6392 swig_obj[0] = args;
6393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6394 if (!SWIG_IsOK(res1)) {
6395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6396 }
6397 arg1 = reinterpret_cast< wxRect * >(argp1);
6398 {
6399 PyThreadState* __tstate = wxPyBeginAllowThreads();
6400 result = (int)((wxRect const *)arg1)->GetHeight();
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 resultobj = SWIG_From_int(static_cast< int >(result));
6405 return resultobj;
6406 fail:
6407 return NULL;
6408 }
6409
6410
6411 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6412 PyObject *resultobj = 0;
6413 wxRect *arg1 = (wxRect *) 0 ;
6414 int arg2 ;
6415 void *argp1 = 0 ;
6416 int res1 = 0 ;
6417 int val2 ;
6418 int ecode2 = 0 ;
6419 PyObject * obj0 = 0 ;
6420 PyObject * obj1 = 0 ;
6421 char * kwnames[] = {
6422 (char *) "self",(char *) "h", NULL
6423 };
6424
6425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6427 if (!SWIG_IsOK(res1)) {
6428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6429 }
6430 arg1 = reinterpret_cast< wxRect * >(argp1);
6431 ecode2 = SWIG_AsVal_int(obj1, &val2);
6432 if (!SWIG_IsOK(ecode2)) {
6433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6434 }
6435 arg2 = static_cast< int >(val2);
6436 {
6437 PyThreadState* __tstate = wxPyBeginAllowThreads();
6438 (arg1)->SetHeight(arg2);
6439 wxPyEndAllowThreads(__tstate);
6440 if (PyErr_Occurred()) SWIG_fail;
6441 }
6442 resultobj = SWIG_Py_Void();
6443 return resultobj;
6444 fail:
6445 return NULL;
6446 }
6447
6448
6449 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6450 PyObject *resultobj = 0;
6451 wxRect *arg1 = (wxRect *) 0 ;
6452 wxPoint result;
6453 void *argp1 = 0 ;
6454 int res1 = 0 ;
6455 PyObject *swig_obj[1] ;
6456
6457 if (!args) SWIG_fail;
6458 swig_obj[0] = args;
6459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6460 if (!SWIG_IsOK(res1)) {
6461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6462 }
6463 arg1 = reinterpret_cast< wxRect * >(argp1);
6464 {
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 result = ((wxRect const *)arg1)->GetPosition();
6467 wxPyEndAllowThreads(__tstate);
6468 if (PyErr_Occurred()) SWIG_fail;
6469 }
6470 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6478 PyObject *resultobj = 0;
6479 wxRect *arg1 = (wxRect *) 0 ;
6480 wxPoint *arg2 = 0 ;
6481 void *argp1 = 0 ;
6482 int res1 = 0 ;
6483 wxPoint temp2 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 char * kwnames[] = {
6487 (char *) "self",(char *) "p", NULL
6488 };
6489
6490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6492 if (!SWIG_IsOK(res1)) {
6493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6494 }
6495 arg1 = reinterpret_cast< wxRect * >(argp1);
6496 {
6497 arg2 = &temp2;
6498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6499 }
6500 {
6501 PyThreadState* __tstate = wxPyBeginAllowThreads();
6502 (arg1)->SetPosition((wxPoint const &)*arg2);
6503 wxPyEndAllowThreads(__tstate);
6504 if (PyErr_Occurred()) SWIG_fail;
6505 }
6506 resultobj = SWIG_Py_Void();
6507 return resultobj;
6508 fail:
6509 return NULL;
6510 }
6511
6512
6513 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6514 PyObject *resultobj = 0;
6515 wxRect *arg1 = (wxRect *) 0 ;
6516 wxSize result;
6517 void *argp1 = 0 ;
6518 int res1 = 0 ;
6519 PyObject *swig_obj[1] ;
6520
6521 if (!args) SWIG_fail;
6522 swig_obj[0] = args;
6523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6524 if (!SWIG_IsOK(res1)) {
6525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6526 }
6527 arg1 = reinterpret_cast< wxRect * >(argp1);
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 result = ((wxRect const *)arg1)->GetSize();
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6542 PyObject *resultobj = 0;
6543 wxRect *arg1 = (wxRect *) 0 ;
6544 wxSize *arg2 = 0 ;
6545 void *argp1 = 0 ;
6546 int res1 = 0 ;
6547 wxSize temp2 ;
6548 PyObject * obj0 = 0 ;
6549 PyObject * obj1 = 0 ;
6550 char * kwnames[] = {
6551 (char *) "self",(char *) "s", NULL
6552 };
6553
6554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6556 if (!SWIG_IsOK(res1)) {
6557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6558 }
6559 arg1 = reinterpret_cast< wxRect * >(argp1);
6560 {
6561 arg2 = &temp2;
6562 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6563 }
6564 {
6565 PyThreadState* __tstate = wxPyBeginAllowThreads();
6566 (arg1)->SetSize((wxSize const &)*arg2);
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 resultobj = SWIG_Py_Void();
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6578 PyObject *resultobj = 0;
6579 wxRect *arg1 = (wxRect *) 0 ;
6580 bool result;
6581 void *argp1 = 0 ;
6582 int res1 = 0 ;
6583 PyObject *swig_obj[1] ;
6584
6585 if (!args) SWIG_fail;
6586 swig_obj[0] = args;
6587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6588 if (!SWIG_IsOK(res1)) {
6589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6590 }
6591 arg1 = reinterpret_cast< wxRect * >(argp1);
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 result = (bool)((wxRect const *)arg1)->IsEmpty();
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 {
6599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6600 }
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 wxRect *arg1 = (wxRect *) 0 ;
6610 wxPoint result;
6611 void *argp1 = 0 ;
6612 int res1 = 0 ;
6613 PyObject *swig_obj[1] ;
6614
6615 if (!args) SWIG_fail;
6616 swig_obj[0] = args;
6617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6618 if (!SWIG_IsOK(res1)) {
6619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6620 }
6621 arg1 = reinterpret_cast< wxRect * >(argp1);
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 result = ((wxRect const *)arg1)->GetTopLeft();
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxPoint *arg2 = 0 ;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 wxPoint temp2 ;
6642 PyObject * obj0 = 0 ;
6643 PyObject * obj1 = 0 ;
6644 char * kwnames[] = {
6645 (char *) "self",(char *) "p", NULL
6646 };
6647
6648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6650 if (!SWIG_IsOK(res1)) {
6651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6652 }
6653 arg1 = reinterpret_cast< wxRect * >(argp1);
6654 {
6655 arg2 = &temp2;
6656 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6657 }
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6672 PyObject *resultobj = 0;
6673 wxRect *arg1 = (wxRect *) 0 ;
6674 wxPoint result;
6675 void *argp1 = 0 ;
6676 int res1 = 0 ;
6677 PyObject *swig_obj[1] ;
6678
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxRect * >(argp1);
6686 {
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 result = ((wxRect const *)arg1)->GetBottomRight();
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxPoint *arg2 = 0 ;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 wxPoint temp2 ;
6706 PyObject * obj0 = 0 ;
6707 PyObject * obj1 = 0 ;
6708 char * kwnames[] = {
6709 (char *) "self",(char *) "p", NULL
6710 };
6711
6712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6714 if (!SWIG_IsOK(res1)) {
6715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6716 }
6717 arg1 = reinterpret_cast< wxRect * >(argp1);
6718 {
6719 arg2 = &temp2;
6720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6721 }
6722 {
6723 PyThreadState* __tstate = wxPyBeginAllowThreads();
6724 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6725 wxPyEndAllowThreads(__tstate);
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 resultobj = SWIG_Py_Void();
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6736 PyObject *resultobj = 0;
6737 wxRect *arg1 = (wxRect *) 0 ;
6738 int result;
6739 void *argp1 = 0 ;
6740 int res1 = 0 ;
6741 PyObject *swig_obj[1] ;
6742
6743 if (!args) SWIG_fail;
6744 swig_obj[0] = args;
6745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6746 if (!SWIG_IsOK(res1)) {
6747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6748 }
6749 arg1 = reinterpret_cast< wxRect * >(argp1);
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 result = (int)((wxRect const *)arg1)->GetLeft();
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_From_int(static_cast< int >(result));
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 int result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (int)((wxRect const *)arg1)->GetTop();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_From_int(static_cast< int >(result));
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6792 PyObject *resultobj = 0;
6793 wxRect *arg1 = (wxRect *) 0 ;
6794 int result;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 PyObject *swig_obj[1] ;
6798
6799 if (!args) SWIG_fail;
6800 swig_obj[0] = args;
6801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6802 if (!SWIG_IsOK(res1)) {
6803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6804 }
6805 arg1 = reinterpret_cast< wxRect * >(argp1);
6806 {
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 result = (int)((wxRect const *)arg1)->GetBottom();
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_From_int(static_cast< int >(result));
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6820 PyObject *resultobj = 0;
6821 wxRect *arg1 = (wxRect *) 0 ;
6822 int result;
6823 void *argp1 = 0 ;
6824 int res1 = 0 ;
6825 PyObject *swig_obj[1] ;
6826
6827 if (!args) SWIG_fail;
6828 swig_obj[0] = args;
6829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6830 if (!SWIG_IsOK(res1)) {
6831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6832 }
6833 arg1 = reinterpret_cast< wxRect * >(argp1);
6834 {
6835 PyThreadState* __tstate = wxPyBeginAllowThreads();
6836 result = (int)((wxRect const *)arg1)->GetRight();
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 resultobj = SWIG_From_int(static_cast< int >(result));
6841 return resultobj;
6842 fail:
6843 return NULL;
6844 }
6845
6846
6847 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6848 PyObject *resultobj = 0;
6849 wxRect *arg1 = (wxRect *) 0 ;
6850 int arg2 ;
6851 void *argp1 = 0 ;
6852 int res1 = 0 ;
6853 int val2 ;
6854 int ecode2 = 0 ;
6855 PyObject * obj0 = 0 ;
6856 PyObject * obj1 = 0 ;
6857 char * kwnames[] = {
6858 (char *) "self",(char *) "left", NULL
6859 };
6860
6861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6865 }
6866 arg1 = reinterpret_cast< wxRect * >(argp1);
6867 ecode2 = SWIG_AsVal_int(obj1, &val2);
6868 if (!SWIG_IsOK(ecode2)) {
6869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6870 }
6871 arg2 = static_cast< int >(val2);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 (arg1)->SetLeft(arg2);
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_Py_Void();
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 int arg2 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 int val2 ;
6892 int ecode2 = 0 ;
6893 PyObject * obj0 = 0 ;
6894 PyObject * obj1 = 0 ;
6895 char * kwnames[] = {
6896 (char *) "self",(char *) "right", NULL
6897 };
6898
6899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6901 if (!SWIG_IsOK(res1)) {
6902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6903 }
6904 arg1 = reinterpret_cast< wxRect * >(argp1);
6905 ecode2 = SWIG_AsVal_int(obj1, &val2);
6906 if (!SWIG_IsOK(ecode2)) {
6907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6908 }
6909 arg2 = static_cast< int >(val2);
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetRight(arg2);
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 resultobj = SWIG_Py_Void();
6917 return resultobj;
6918 fail:
6919 return NULL;
6920 }
6921
6922
6923 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj = 0;
6925 wxRect *arg1 = (wxRect *) 0 ;
6926 int arg2 ;
6927 void *argp1 = 0 ;
6928 int res1 = 0 ;
6929 int val2 ;
6930 int ecode2 = 0 ;
6931 PyObject * obj0 = 0 ;
6932 PyObject * obj1 = 0 ;
6933 char * kwnames[] = {
6934 (char *) "self",(char *) "top", NULL
6935 };
6936
6937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6939 if (!SWIG_IsOK(res1)) {
6940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6941 }
6942 arg1 = reinterpret_cast< wxRect * >(argp1);
6943 ecode2 = SWIG_AsVal_int(obj1, &val2);
6944 if (!SWIG_IsOK(ecode2)) {
6945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6946 }
6947 arg2 = static_cast< int >(val2);
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 (arg1)->SetTop(arg2);
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 resultobj = SWIG_Py_Void();
6955 return resultobj;
6956 fail:
6957 return NULL;
6958 }
6959
6960
6961 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6962 PyObject *resultobj = 0;
6963 wxRect *arg1 = (wxRect *) 0 ;
6964 int arg2 ;
6965 void *argp1 = 0 ;
6966 int res1 = 0 ;
6967 int val2 ;
6968 int ecode2 = 0 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 char * kwnames[] = {
6972 (char *) "self",(char *) "bottom", NULL
6973 };
6974
6975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6977 if (!SWIG_IsOK(res1)) {
6978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6979 }
6980 arg1 = reinterpret_cast< wxRect * >(argp1);
6981 ecode2 = SWIG_AsVal_int(obj1, &val2);
6982 if (!SWIG_IsOK(ecode2)) {
6983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6984 }
6985 arg2 = static_cast< int >(val2);
6986 {
6987 PyThreadState* __tstate = wxPyBeginAllowThreads();
6988 (arg1)->SetBottom(arg2);
6989 wxPyEndAllowThreads(__tstate);
6990 if (PyErr_Occurred()) SWIG_fail;
6991 }
6992 resultobj = SWIG_Py_Void();
6993 return resultobj;
6994 fail:
6995 return NULL;
6996 }
6997
6998
6999 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7000 PyObject *resultobj = 0;
7001 wxRect *arg1 = (wxRect *) 0 ;
7002 int arg2 ;
7003 int arg3 ;
7004 wxRect *result = 0 ;
7005 void *argp1 = 0 ;
7006 int res1 = 0 ;
7007 int val2 ;
7008 int ecode2 = 0 ;
7009 int val3 ;
7010 int ecode3 = 0 ;
7011 PyObject * obj0 = 0 ;
7012 PyObject * obj1 = 0 ;
7013 PyObject * obj2 = 0 ;
7014 char * kwnames[] = {
7015 (char *) "self",(char *) "dx",(char *) "dy", NULL
7016 };
7017
7018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7022 }
7023 arg1 = reinterpret_cast< wxRect * >(argp1);
7024 ecode2 = SWIG_AsVal_int(obj1, &val2);
7025 if (!SWIG_IsOK(ecode2)) {
7026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7027 }
7028 arg2 = static_cast< int >(val2);
7029 ecode3 = SWIG_AsVal_int(obj2, &val3);
7030 if (!SWIG_IsOK(ecode3)) {
7031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7032 }
7033 arg3 = static_cast< int >(val3);
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 {
7037 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7038 result = (wxRect *) &_result_ref;
7039 }
7040 wxPyEndAllowThreads(__tstate);
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int arg2 ;
7054 int arg3 ;
7055 wxRect *result = 0 ;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 int val2 ;
7059 int ecode2 = 0 ;
7060 int val3 ;
7061 int ecode3 = 0 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 PyObject * obj2 = 0 ;
7065 char * kwnames[] = {
7066 (char *) "self",(char *) "dx",(char *) "dy", NULL
7067 };
7068
7069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 ecode2 = SWIG_AsVal_int(obj1, &val2);
7076 if (!SWIG_IsOK(ecode2)) {
7077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7078 }
7079 arg2 = static_cast< int >(val2);
7080 ecode3 = SWIG_AsVal_int(obj2, &val3);
7081 if (!SWIG_IsOK(ecode3)) {
7082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7083 }
7084 arg3 = static_cast< int >(val3);
7085 {
7086 PyThreadState* __tstate = wxPyBeginAllowThreads();
7087 {
7088 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7089 result = (wxRect *) &_result_ref;
7090 }
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7102 PyObject *resultobj = 0;
7103 wxRect *arg1 = (wxRect *) 0 ;
7104 int arg2 ;
7105 int arg3 ;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 int val2 ;
7109 int ecode2 = 0 ;
7110 int val3 ;
7111 int ecode3 = 0 ;
7112 PyObject * obj0 = 0 ;
7113 PyObject * obj1 = 0 ;
7114 PyObject * obj2 = 0 ;
7115 char * kwnames[] = {
7116 (char *) "self",(char *) "dx",(char *) "dy", NULL
7117 };
7118
7119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7121 if (!SWIG_IsOK(res1)) {
7122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7123 }
7124 arg1 = reinterpret_cast< wxRect * >(argp1);
7125 ecode2 = SWIG_AsVal_int(obj1, &val2);
7126 if (!SWIG_IsOK(ecode2)) {
7127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7128 }
7129 arg2 = static_cast< int >(val2);
7130 ecode3 = SWIG_AsVal_int(obj2, &val3);
7131 if (!SWIG_IsOK(ecode3)) {
7132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7133 }
7134 arg3 = static_cast< int >(val3);
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 (arg1)->Offset(arg2,arg3);
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_Py_Void();
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 wxPoint *arg2 = 0 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 wxPoint temp2 ;
7155 PyObject * obj0 = 0 ;
7156 PyObject * obj1 = 0 ;
7157 char * kwnames[] = {
7158 (char *) "self",(char *) "pt", NULL
7159 };
7160
7161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7163 if (!SWIG_IsOK(res1)) {
7164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7165 }
7166 arg1 = reinterpret_cast< wxRect * >(argp1);
7167 {
7168 arg2 = &temp2;
7169 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7170 }
7171 {
7172 PyThreadState* __tstate = wxPyBeginAllowThreads();
7173 (arg1)->Offset((wxPoint const &)*arg2);
7174 wxPyEndAllowThreads(__tstate);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_Py_Void();
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxRect *arg1 = (wxRect *) 0 ;
7187 wxRect *arg2 = 0 ;
7188 wxRect result;
7189 void *argp1 = 0 ;
7190 int res1 = 0 ;
7191 wxRect temp2 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "rect", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7202 }
7203 arg1 = reinterpret_cast< wxRect * >(argp1);
7204 {
7205 arg2 = &temp2;
7206 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7207 }
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 result = (arg1)->Intersect((wxRect const &)*arg2);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxRect *arg1 = (wxRect *) 0 ;
7224 wxRect *arg2 = 0 ;
7225 wxRect result;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 wxRect temp2 ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 char * kwnames[] = {
7232 (char *) "self",(char *) "rect", NULL
7233 };
7234
7235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7237 if (!SWIG_IsOK(res1)) {
7238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7239 }
7240 arg1 = reinterpret_cast< wxRect * >(argp1);
7241 {
7242 arg2 = &temp2;
7243 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7244 }
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 result = (arg1)->Union((wxRect const &)*arg2);
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxRect *arg1 = (wxRect *) 0 ;
7261 wxRect *arg2 = 0 ;
7262 wxRect result;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 wxRect temp2 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "self",(char *) "rect", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7274 if (!SWIG_IsOK(res1)) {
7275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7276 }
7277 arg1 = reinterpret_cast< wxRect * >(argp1);
7278 {
7279 arg2 = &temp2;
7280 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7281 }
7282 {
7283 PyThreadState* __tstate = wxPyBeginAllowThreads();
7284 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7285 wxPyEndAllowThreads(__tstate);
7286 if (PyErr_Occurred()) SWIG_fail;
7287 }
7288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7289 return resultobj;
7290 fail:
7291 return NULL;
7292 }
7293
7294
7295 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7296 PyObject *resultobj = 0;
7297 wxRect *arg1 = (wxRect *) 0 ;
7298 wxRect *arg2 = 0 ;
7299 wxRect *result = 0 ;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 wxRect temp2 ;
7303 PyObject * obj0 = 0 ;
7304 PyObject * obj1 = 0 ;
7305 char * kwnames[] = {
7306 (char *) "self",(char *) "rect", NULL
7307 };
7308
7309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7311 if (!SWIG_IsOK(res1)) {
7312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7313 }
7314 arg1 = reinterpret_cast< wxRect * >(argp1);
7315 {
7316 arg2 = &temp2;
7317 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7318 }
7319 {
7320 PyThreadState* __tstate = wxPyBeginAllowThreads();
7321 {
7322 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7323 result = (wxRect *) &_result_ref;
7324 }
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 PyObject *arg2 = (PyObject *) 0 ;
7339 bool result;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 char * kwnames[] = {
7345 (char *) "self",(char *) "other", NULL
7346 };
7347
7348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7350 if (!SWIG_IsOK(res1)) {
7351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7352 }
7353 arg1 = reinterpret_cast< wxRect * >(argp1);
7354 arg2 = obj1;
7355 {
7356 result = (bool)wxRect___eq__(arg1,arg2);
7357 if (PyErr_Occurred()) SWIG_fail;
7358 }
7359 {
7360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7361 }
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 PyObject *arg2 = (PyObject *) 0 ;
7372 bool result;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 PyObject * obj0 = 0 ;
7376 PyObject * obj1 = 0 ;
7377 char * kwnames[] = {
7378 (char *) "self",(char *) "other", NULL
7379 };
7380
7381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7383 if (!SWIG_IsOK(res1)) {
7384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7385 }
7386 arg1 = reinterpret_cast< wxRect * >(argp1);
7387 arg2 = obj1;
7388 {
7389 result = (bool)wxRect___ne__(arg1,arg2);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 {
7393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7394 }
7395 return resultobj;
7396 fail:
7397 return NULL;
7398 }
7399
7400
7401 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7402 PyObject *resultobj = 0;
7403 wxRect *arg1 = (wxRect *) 0 ;
7404 int arg2 ;
7405 int arg3 ;
7406 bool result;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 int val2 ;
7410 int ecode2 = 0 ;
7411 int val3 ;
7412 int ecode3 = 0 ;
7413 PyObject * obj0 = 0 ;
7414 PyObject * obj1 = 0 ;
7415 PyObject * obj2 = 0 ;
7416 char * kwnames[] = {
7417 (char *) "self",(char *) "x",(char *) "y", NULL
7418 };
7419
7420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7424 }
7425 arg1 = reinterpret_cast< wxRect * >(argp1);
7426 ecode2 = SWIG_AsVal_int(obj1, &val2);
7427 if (!SWIG_IsOK(ecode2)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7429 }
7430 arg2 = static_cast< int >(val2);
7431 ecode3 = SWIG_AsVal_int(obj2, &val3);
7432 if (!SWIG_IsOK(ecode3)) {
7433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7434 }
7435 arg3 = static_cast< int >(val3);
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 {
7443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7444 }
7445 return resultobj;
7446 fail:
7447 return NULL;
7448 }
7449
7450
7451 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7452 PyObject *resultobj = 0;
7453 wxRect *arg1 = (wxRect *) 0 ;
7454 wxPoint *arg2 = 0 ;
7455 bool result;
7456 void *argp1 = 0 ;
7457 int res1 = 0 ;
7458 wxPoint temp2 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 char * kwnames[] = {
7462 (char *) "self",(char *) "pt", NULL
7463 };
7464
7465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7467 if (!SWIG_IsOK(res1)) {
7468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7469 }
7470 arg1 = reinterpret_cast< wxRect * >(argp1);
7471 {
7472 arg2 = &temp2;
7473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7474 }
7475 {
7476 PyThreadState* __tstate = wxPyBeginAllowThreads();
7477 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 {
7482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7483 }
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7491 PyObject *resultobj = 0;
7492 wxRect *arg1 = (wxRect *) 0 ;
7493 wxRect *arg2 = 0 ;
7494 bool result;
7495 void *argp1 = 0 ;
7496 int res1 = 0 ;
7497 wxRect temp2 ;
7498 PyObject * obj0 = 0 ;
7499 PyObject * obj1 = 0 ;
7500 char * kwnames[] = {
7501 (char *) "self",(char *) "rect", NULL
7502 };
7503
7504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7506 if (!SWIG_IsOK(res1)) {
7507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7508 }
7509 arg1 = reinterpret_cast< wxRect * >(argp1);
7510 {
7511 arg2 = &temp2;
7512 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7513 }
7514 {
7515 PyThreadState* __tstate = wxPyBeginAllowThreads();
7516 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7517 wxPyEndAllowThreads(__tstate);
7518 if (PyErr_Occurred()) SWIG_fail;
7519 }
7520 {
7521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7522 }
7523 return resultobj;
7524 fail:
7525 return NULL;
7526 }
7527
7528
7529 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7530 PyObject *resultobj = 0;
7531 wxRect *arg1 = (wxRect *) 0 ;
7532 wxRect *arg2 = 0 ;
7533 int arg3 = (int) wxBOTH ;
7534 wxRect result;
7535 void *argp1 = 0 ;
7536 int res1 = 0 ;
7537 wxRect temp2 ;
7538 int val3 ;
7539 int ecode3 = 0 ;
7540 PyObject * obj0 = 0 ;
7541 PyObject * obj1 = 0 ;
7542 PyObject * obj2 = 0 ;
7543 char * kwnames[] = {
7544 (char *) "self",(char *) "r",(char *) "dir", NULL
7545 };
7546
7547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7549 if (!SWIG_IsOK(res1)) {
7550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7551 }
7552 arg1 = reinterpret_cast< wxRect * >(argp1);
7553 {
7554 arg2 = &temp2;
7555 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7556 }
7557 if (obj2) {
7558 ecode3 = SWIG_AsVal_int(obj2, &val3);
7559 if (!SWIG_IsOK(ecode3)) {
7560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7561 }
7562 arg3 = static_cast< int >(val3);
7563 }
7564 {
7565 PyThreadState* __tstate = wxPyBeginAllowThreads();
7566 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7567 wxPyEndAllowThreads(__tstate);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7578 PyObject *resultobj = 0;
7579 wxRect *arg1 = (wxRect *) 0 ;
7580 int arg2 ;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 int val2 ;
7584 int ecode2 = 0 ;
7585 PyObject *swig_obj[2] ;
7586
7587 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7589 if (!SWIG_IsOK(res1)) {
7590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7591 }
7592 arg1 = reinterpret_cast< wxRect * >(argp1);
7593 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7594 if (!SWIG_IsOK(ecode2)) {
7595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7596 }
7597 arg2 = static_cast< int >(val2);
7598 if (arg1) (arg1)->x = arg2;
7599
7600 resultobj = SWIG_Py_Void();
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7608 PyObject *resultobj = 0;
7609 wxRect *arg1 = (wxRect *) 0 ;
7610 int result;
7611 void *argp1 = 0 ;
7612 int res1 = 0 ;
7613 PyObject *swig_obj[1] ;
7614
7615 if (!args) SWIG_fail;
7616 swig_obj[0] = args;
7617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7618 if (!SWIG_IsOK(res1)) {
7619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7620 }
7621 arg1 = reinterpret_cast< wxRect * >(argp1);
7622 result = (int) ((arg1)->x);
7623 resultobj = SWIG_From_int(static_cast< int >(result));
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7631 PyObject *resultobj = 0;
7632 wxRect *arg1 = (wxRect *) 0 ;
7633 int arg2 ;
7634 void *argp1 = 0 ;
7635 int res1 = 0 ;
7636 int val2 ;
7637 int ecode2 = 0 ;
7638 PyObject *swig_obj[2] ;
7639
7640 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7642 if (!SWIG_IsOK(res1)) {
7643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7644 }
7645 arg1 = reinterpret_cast< wxRect * >(argp1);
7646 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7647 if (!SWIG_IsOK(ecode2)) {
7648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7649 }
7650 arg2 = static_cast< int >(val2);
7651 if (arg1) (arg1)->y = arg2;
7652
7653 resultobj = SWIG_Py_Void();
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7661 PyObject *resultobj = 0;
7662 wxRect *arg1 = (wxRect *) 0 ;
7663 int result;
7664 void *argp1 = 0 ;
7665 int res1 = 0 ;
7666 PyObject *swig_obj[1] ;
7667
7668 if (!args) SWIG_fail;
7669 swig_obj[0] = args;
7670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7671 if (!SWIG_IsOK(res1)) {
7672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7673 }
7674 arg1 = reinterpret_cast< wxRect * >(argp1);
7675 result = (int) ((arg1)->y);
7676 resultobj = SWIG_From_int(static_cast< int >(result));
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7684 PyObject *resultobj = 0;
7685 wxRect *arg1 = (wxRect *) 0 ;
7686 int arg2 ;
7687 void *argp1 = 0 ;
7688 int res1 = 0 ;
7689 int val2 ;
7690 int ecode2 = 0 ;
7691 PyObject *swig_obj[2] ;
7692
7693 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7697 }
7698 arg1 = reinterpret_cast< wxRect * >(argp1);
7699 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7700 if (!SWIG_IsOK(ecode2)) {
7701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7702 }
7703 arg2 = static_cast< int >(val2);
7704 if (arg1) (arg1)->width = arg2;
7705
7706 resultobj = SWIG_Py_Void();
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7714 PyObject *resultobj = 0;
7715 wxRect *arg1 = (wxRect *) 0 ;
7716 int result;
7717 void *argp1 = 0 ;
7718 int res1 = 0 ;
7719 PyObject *swig_obj[1] ;
7720
7721 if (!args) SWIG_fail;
7722 swig_obj[0] = args;
7723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7724 if (!SWIG_IsOK(res1)) {
7725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7726 }
7727 arg1 = reinterpret_cast< wxRect * >(argp1);
7728 result = (int) ((arg1)->width);
7729 resultobj = SWIG_From_int(static_cast< int >(result));
7730 return resultobj;
7731 fail:
7732 return NULL;
7733 }
7734
7735
7736 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7737 PyObject *resultobj = 0;
7738 wxRect *arg1 = (wxRect *) 0 ;
7739 int arg2 ;
7740 void *argp1 = 0 ;
7741 int res1 = 0 ;
7742 int val2 ;
7743 int ecode2 = 0 ;
7744 PyObject *swig_obj[2] ;
7745
7746 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7748 if (!SWIG_IsOK(res1)) {
7749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7750 }
7751 arg1 = reinterpret_cast< wxRect * >(argp1);
7752 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7753 if (!SWIG_IsOK(ecode2)) {
7754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7755 }
7756 arg2 = static_cast< int >(val2);
7757 if (arg1) (arg1)->height = arg2;
7758
7759 resultobj = SWIG_Py_Void();
7760 return resultobj;
7761 fail:
7762 return NULL;
7763 }
7764
7765
7766 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7767 PyObject *resultobj = 0;
7768 wxRect *arg1 = (wxRect *) 0 ;
7769 int result;
7770 void *argp1 = 0 ;
7771 int res1 = 0 ;
7772 PyObject *swig_obj[1] ;
7773
7774 if (!args) SWIG_fail;
7775 swig_obj[0] = args;
7776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7777 if (!SWIG_IsOK(res1)) {
7778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7779 }
7780 arg1 = reinterpret_cast< wxRect * >(argp1);
7781 result = (int) ((arg1)->height);
7782 resultobj = SWIG_From_int(static_cast< int >(result));
7783 return resultobj;
7784 fail:
7785 return NULL;
7786 }
7787
7788
7789 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7790 PyObject *resultobj = 0;
7791 wxRect *arg1 = (wxRect *) 0 ;
7792 int arg2 = (int) 0 ;
7793 int arg3 = (int) 0 ;
7794 int arg4 = (int) 0 ;
7795 int arg5 = (int) 0 ;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 int val2 ;
7799 int ecode2 = 0 ;
7800 int val3 ;
7801 int ecode3 = 0 ;
7802 int val4 ;
7803 int ecode4 = 0 ;
7804 int val5 ;
7805 int ecode5 = 0 ;
7806 PyObject * obj0 = 0 ;
7807 PyObject * obj1 = 0 ;
7808 PyObject * obj2 = 0 ;
7809 PyObject * obj3 = 0 ;
7810 PyObject * obj4 = 0 ;
7811 char * kwnames[] = {
7812 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7813 };
7814
7815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7817 if (!SWIG_IsOK(res1)) {
7818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7819 }
7820 arg1 = reinterpret_cast< wxRect * >(argp1);
7821 if (obj1) {
7822 ecode2 = SWIG_AsVal_int(obj1, &val2);
7823 if (!SWIG_IsOK(ecode2)) {
7824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7825 }
7826 arg2 = static_cast< int >(val2);
7827 }
7828 if (obj2) {
7829 ecode3 = SWIG_AsVal_int(obj2, &val3);
7830 if (!SWIG_IsOK(ecode3)) {
7831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7832 }
7833 arg3 = static_cast< int >(val3);
7834 }
7835 if (obj3) {
7836 ecode4 = SWIG_AsVal_int(obj3, &val4);
7837 if (!SWIG_IsOK(ecode4)) {
7838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7839 }
7840 arg4 = static_cast< int >(val4);
7841 }
7842 if (obj4) {
7843 ecode5 = SWIG_AsVal_int(obj4, &val5);
7844 if (!SWIG_IsOK(ecode5)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7846 }
7847 arg5 = static_cast< int >(val5);
7848 }
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 resultobj = SWIG_Py_Void();
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 PyObject *result = 0 ;
7866 void *argp1 = 0 ;
7867 int res1 = 0 ;
7868 PyObject *swig_obj[1] ;
7869
7870 if (!args) SWIG_fail;
7871 swig_obj[0] = args;
7872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7873 if (!SWIG_IsOK(res1)) {
7874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7875 }
7876 arg1 = reinterpret_cast< wxRect * >(argp1);
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 result = (PyObject *)wxRect_Get(arg1);
7880 wxPyEndAllowThreads(__tstate);
7881 if (PyErr_Occurred()) SWIG_fail;
7882 }
7883 resultobj = result;
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7891 PyObject *obj;
7892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7893 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7894 return SWIG_Py_Void();
7895 }
7896
7897 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7898 return SWIG_Python_InitShadowInstance(args);
7899 }
7900
7901 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7902 PyObject *resultobj = 0;
7903 wxRect *arg1 = (wxRect *) 0 ;
7904 wxRect *arg2 = (wxRect *) 0 ;
7905 PyObject *result = 0 ;
7906 void *argp1 = 0 ;
7907 int res1 = 0 ;
7908 void *argp2 = 0 ;
7909 int res2 = 0 ;
7910 PyObject * obj0 = 0 ;
7911 PyObject * obj1 = 0 ;
7912 char * kwnames[] = {
7913 (char *) "r1",(char *) "r2", NULL
7914 };
7915
7916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7918 if (!SWIG_IsOK(res1)) {
7919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7920 }
7921 arg1 = reinterpret_cast< wxRect * >(argp1);
7922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7923 if (!SWIG_IsOK(res2)) {
7924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7925 }
7926 arg2 = reinterpret_cast< wxRect * >(argp2);
7927 {
7928 if (!wxPyCheckForApp()) SWIG_fail;
7929 PyThreadState* __tstate = wxPyBeginAllowThreads();
7930 result = (PyObject *)wxIntersectRect(arg1,arg2);
7931 wxPyEndAllowThreads(__tstate);
7932 if (PyErr_Occurred()) SWIG_fail;
7933 }
7934 resultobj = result;
7935 return resultobj;
7936 fail:
7937 return NULL;
7938 }
7939
7940
7941 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7942 PyObject *resultobj = 0;
7943 double arg1 = (double) 0.0 ;
7944 double arg2 = (double) 0.0 ;
7945 wxPoint2D *result = 0 ;
7946 double val1 ;
7947 int ecode1 = 0 ;
7948 double val2 ;
7949 int ecode2 = 0 ;
7950 PyObject * obj0 = 0 ;
7951 PyObject * obj1 = 0 ;
7952 char * kwnames[] = {
7953 (char *) "x",(char *) "y", NULL
7954 };
7955
7956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7957 if (obj0) {
7958 ecode1 = SWIG_AsVal_double(obj0, &val1);
7959 if (!SWIG_IsOK(ecode1)) {
7960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7961 }
7962 arg1 = static_cast< double >(val1);
7963 }
7964 if (obj1) {
7965 ecode2 = SWIG_AsVal_double(obj1, &val2);
7966 if (!SWIG_IsOK(ecode2)) {
7967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7968 }
7969 arg2 = static_cast< double >(val2);
7970 }
7971 {
7972 PyThreadState* __tstate = wxPyBeginAllowThreads();
7973 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7974 wxPyEndAllowThreads(__tstate);
7975 if (PyErr_Occurred()) SWIG_fail;
7976 }
7977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7978 return resultobj;
7979 fail:
7980 return NULL;
7981 }
7982
7983
7984 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7985 PyObject *resultobj = 0;
7986 wxPoint2D *arg1 = 0 ;
7987 wxPoint2D *result = 0 ;
7988 wxPoint2D temp1 ;
7989 PyObject * obj0 = 0 ;
7990 char * kwnames[] = {
7991 (char *) "pt", NULL
7992 };
7993
7994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7995 {
7996 arg1 = &temp1;
7997 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7998 }
7999 {
8000 PyThreadState* __tstate = wxPyBeginAllowThreads();
8001 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8002 wxPyEndAllowThreads(__tstate);
8003 if (PyErr_Occurred()) SWIG_fail;
8004 }
8005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8006 return resultobj;
8007 fail:
8008 return NULL;
8009 }
8010
8011
8012 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8013 PyObject *resultobj = 0;
8014 wxPoint *arg1 = 0 ;
8015 wxPoint2D *result = 0 ;
8016 wxPoint temp1 ;
8017 PyObject * obj0 = 0 ;
8018 char * kwnames[] = {
8019 (char *) "pt", NULL
8020 };
8021
8022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8023 {
8024 arg1 = &temp1;
8025 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8026 }
8027 {
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8030 wxPyEndAllowThreads(__tstate);
8031 if (PyErr_Occurred()) SWIG_fail;
8032 }
8033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8043 int *arg2 = (int *) 0 ;
8044 int *arg3 = (int *) 0 ;
8045 void *argp1 = 0 ;
8046 int res1 = 0 ;
8047 int temp2 ;
8048 int res2 = SWIG_TMPOBJ ;
8049 int temp3 ;
8050 int res3 = SWIG_TMPOBJ ;
8051 PyObject *swig_obj[1] ;
8052
8053 arg2 = &temp2;
8054 arg3 = &temp3;
8055 if (!args) SWIG_fail;
8056 swig_obj[0] = args;
8057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8058 if (!SWIG_IsOK(res1)) {
8059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8060 }
8061 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8065 wxPyEndAllowThreads(__tstate);
8066 if (PyErr_Occurred()) SWIG_fail;
8067 }
8068 resultobj = SWIG_Py_Void();
8069 if (SWIG_IsTmpObj(res2)) {
8070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8071 } else {
8072 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8074 }
8075 if (SWIG_IsTmpObj(res3)) {
8076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8077 } else {
8078 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8080 }
8081 return resultobj;
8082 fail:
8083 return NULL;
8084 }
8085
8086
8087 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8088 PyObject *resultobj = 0;
8089 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8090 int *arg2 = (int *) 0 ;
8091 int *arg3 = (int *) 0 ;
8092 void *argp1 = 0 ;
8093 int res1 = 0 ;
8094 int temp2 ;
8095 int res2 = SWIG_TMPOBJ ;
8096 int temp3 ;
8097 int res3 = SWIG_TMPOBJ ;
8098 PyObject *swig_obj[1] ;
8099
8100 arg2 = &temp2;
8101 arg3 = &temp3;
8102 if (!args) SWIG_fail;
8103 swig_obj[0] = args;
8104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8105 if (!SWIG_IsOK(res1)) {
8106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8107 }
8108 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8109 {
8110 PyThreadState* __tstate = wxPyBeginAllowThreads();
8111 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 resultobj = SWIG_Py_Void();
8116 if (SWIG_IsTmpObj(res2)) {
8117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8118 } else {
8119 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8121 }
8122 if (SWIG_IsTmpObj(res3)) {
8123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8124 } else {
8125 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8127 }
8128 return resultobj;
8129 fail:
8130 return NULL;
8131 }
8132
8133
8134 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8135 PyObject *resultobj = 0;
8136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8137 double result;
8138 void *argp1 = 0 ;
8139 int res1 = 0 ;
8140 PyObject *swig_obj[1] ;
8141
8142 if (!args) SWIG_fail;
8143 swig_obj[0] = args;
8144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8145 if (!SWIG_IsOK(res1)) {
8146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8147 }
8148 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8149 {
8150 PyThreadState* __tstate = wxPyBeginAllowThreads();
8151 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8152 wxPyEndAllowThreads(__tstate);
8153 if (PyErr_Occurred()) SWIG_fail;
8154 }
8155 resultobj = SWIG_From_double(static_cast< double >(result));
8156 return resultobj;
8157 fail:
8158 return NULL;
8159 }
8160
8161
8162 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8163 PyObject *resultobj = 0;
8164 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8165 double result;
8166 void *argp1 = 0 ;
8167 int res1 = 0 ;
8168 PyObject *swig_obj[1] ;
8169
8170 if (!args) SWIG_fail;
8171 swig_obj[0] = args;
8172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8175 }
8176 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8177 {
8178 PyThreadState* __tstate = wxPyBeginAllowThreads();
8179 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8180 wxPyEndAllowThreads(__tstate);
8181 if (PyErr_Occurred()) SWIG_fail;
8182 }
8183 resultobj = SWIG_From_double(static_cast< double >(result));
8184 return resultobj;
8185 fail:
8186 return NULL;
8187 }
8188
8189
8190 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8191 PyObject *resultobj = 0;
8192 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8193 double arg2 ;
8194 void *argp1 = 0 ;
8195 int res1 = 0 ;
8196 double val2 ;
8197 int ecode2 = 0 ;
8198 PyObject * obj0 = 0 ;
8199 PyObject * obj1 = 0 ;
8200 char * kwnames[] = {
8201 (char *) "self",(char *) "length", NULL
8202 };
8203
8204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8206 if (!SWIG_IsOK(res1)) {
8207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8208 }
8209 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8210 ecode2 = SWIG_AsVal_double(obj1, &val2);
8211 if (!SWIG_IsOK(ecode2)) {
8212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8213 }
8214 arg2 = static_cast< double >(val2);
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 (arg1)->SetVectorLength(arg2);
8218 wxPyEndAllowThreads(__tstate);
8219 if (PyErr_Occurred()) SWIG_fail;
8220 }
8221 resultobj = SWIG_Py_Void();
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8229 PyObject *resultobj = 0;
8230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8231 double arg2 ;
8232 void *argp1 = 0 ;
8233 int res1 = 0 ;
8234 double val2 ;
8235 int ecode2 = 0 ;
8236 PyObject * obj0 = 0 ;
8237 PyObject * obj1 = 0 ;
8238 char * kwnames[] = {
8239 (char *) "self",(char *) "degrees", NULL
8240 };
8241
8242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8244 if (!SWIG_IsOK(res1)) {
8245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8246 }
8247 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8248 ecode2 = SWIG_AsVal_double(obj1, &val2);
8249 if (!SWIG_IsOK(ecode2)) {
8250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8251 }
8252 arg2 = static_cast< double >(val2);
8253 {
8254 PyThreadState* __tstate = wxPyBeginAllowThreads();
8255 (arg1)->SetVectorAngle(arg2);
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 resultobj = SWIG_Py_Void();
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8267 PyObject *resultobj = 0;
8268 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8269 wxPoint2D *arg2 = 0 ;
8270 double result;
8271 void *argp1 = 0 ;
8272 int res1 = 0 ;
8273 wxPoint2D temp2 ;
8274 PyObject * obj0 = 0 ;
8275 PyObject * obj1 = 0 ;
8276 char * kwnames[] = {
8277 (char *) "self",(char *) "pt", NULL
8278 };
8279
8280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8282 if (!SWIG_IsOK(res1)) {
8283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8284 }
8285 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8286 {
8287 arg2 = &temp2;
8288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8289 }
8290 {
8291 PyThreadState* __tstate = wxPyBeginAllowThreads();
8292 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 resultobj = SWIG_From_double(static_cast< double >(result));
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj = 0;
8305 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8306 wxPoint2D *arg2 = 0 ;
8307 double result;
8308 void *argp1 = 0 ;
8309 int res1 = 0 ;
8310 wxPoint2D temp2 ;
8311 PyObject * obj0 = 0 ;
8312 PyObject * obj1 = 0 ;
8313 char * kwnames[] = {
8314 (char *) "self",(char *) "pt", NULL
8315 };
8316
8317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8319 if (!SWIG_IsOK(res1)) {
8320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8321 }
8322 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8323 {
8324 arg2 = &temp2;
8325 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_From_double(static_cast< double >(result));
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8343 wxPoint2D *arg2 = 0 ;
8344 double result;
8345 void *argp1 = 0 ;
8346 int res1 = 0 ;
8347 wxPoint2D temp2 ;
8348 PyObject * obj0 = 0 ;
8349 PyObject * obj1 = 0 ;
8350 char * kwnames[] = {
8351 (char *) "self",(char *) "vec", NULL
8352 };
8353
8354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8356 if (!SWIG_IsOK(res1)) {
8357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8358 }
8359 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8360 {
8361 arg2 = &temp2;
8362 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8363 }
8364 {
8365 PyThreadState* __tstate = wxPyBeginAllowThreads();
8366 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8367 wxPyEndAllowThreads(__tstate);
8368 if (PyErr_Occurred()) SWIG_fail;
8369 }
8370 resultobj = SWIG_From_double(static_cast< double >(result));
8371 return resultobj;
8372 fail:
8373 return NULL;
8374 }
8375
8376
8377 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8378 PyObject *resultobj = 0;
8379 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8380 wxPoint2D *arg2 = 0 ;
8381 double result;
8382 void *argp1 = 0 ;
8383 int res1 = 0 ;
8384 wxPoint2D temp2 ;
8385 PyObject * obj0 = 0 ;
8386 PyObject * obj1 = 0 ;
8387 char * kwnames[] = {
8388 (char *) "self",(char *) "vec", NULL
8389 };
8390
8391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8393 if (!SWIG_IsOK(res1)) {
8394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8395 }
8396 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8397 {
8398 arg2 = &temp2;
8399 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8400 }
8401 {
8402 PyThreadState* __tstate = wxPyBeginAllowThreads();
8403 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8404 wxPyEndAllowThreads(__tstate);
8405 if (PyErr_Occurred()) SWIG_fail;
8406 }
8407 resultobj = SWIG_From_double(static_cast< double >(result));
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8415 PyObject *resultobj = 0;
8416 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8417 wxPoint2D result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 PyObject *swig_obj[1] ;
8421
8422 if (!args) SWIG_fail;
8423 swig_obj[0] = args;
8424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8427 }
8428 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8429 {
8430 PyThreadState* __tstate = wxPyBeginAllowThreads();
8431 result = (arg1)->operator -();
8432 wxPyEndAllowThreads(__tstate);
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 wxPoint2D *arg2 = 0 ;
8446 wxPoint2D *result = 0 ;
8447 void *argp1 = 0 ;
8448 int res1 = 0 ;
8449 wxPoint2D temp2 ;
8450 PyObject * obj0 = 0 ;
8451 PyObject * obj1 = 0 ;
8452 char * kwnames[] = {
8453 (char *) "self",(char *) "pt", NULL
8454 };
8455
8456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8458 if (!SWIG_IsOK(res1)) {
8459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8460 }
8461 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8462 {
8463 arg2 = &temp2;
8464 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8465 }
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 {
8469 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8470 result = (wxPoint2D *) &_result_ref;
8471 }
8472 wxPyEndAllowThreads(__tstate);
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8476 return resultobj;
8477 fail:
8478 return NULL;
8479 }
8480
8481
8482 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8483 PyObject *resultobj = 0;
8484 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8485 wxPoint2D *arg2 = 0 ;
8486 wxPoint2D *result = 0 ;
8487 void *argp1 = 0 ;
8488 int res1 = 0 ;
8489 wxPoint2D temp2 ;
8490 PyObject * obj0 = 0 ;
8491 PyObject * obj1 = 0 ;
8492 char * kwnames[] = {
8493 (char *) "self",(char *) "pt", NULL
8494 };
8495
8496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 arg2 = &temp2;
8504 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8505 }
8506 {
8507 PyThreadState* __tstate = wxPyBeginAllowThreads();
8508 {
8509 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8510 result = (wxPoint2D *) &_result_ref;
8511 }
8512 wxPyEndAllowThreads(__tstate);
8513 if (PyErr_Occurred()) SWIG_fail;
8514 }
8515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8516 return resultobj;
8517 fail:
8518 return NULL;
8519 }
8520
8521
8522 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8523 PyObject *resultobj = 0;
8524 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8525 wxPoint2D *arg2 = 0 ;
8526 wxPoint2D *result = 0 ;
8527 void *argp1 = 0 ;
8528 int res1 = 0 ;
8529 wxPoint2D temp2 ;
8530 PyObject * obj0 = 0 ;
8531 PyObject * obj1 = 0 ;
8532 char * kwnames[] = {
8533 (char *) "self",(char *) "pt", NULL
8534 };
8535
8536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8538 if (!SWIG_IsOK(res1)) {
8539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8540 }
8541 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8542 {
8543 arg2 = &temp2;
8544 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8545 }
8546 {
8547 PyThreadState* __tstate = wxPyBeginAllowThreads();
8548 {
8549 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8550 result = (wxPoint2D *) &_result_ref;
8551 }
8552 wxPyEndAllowThreads(__tstate);
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj = 0;
8564 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8565 wxPoint2D *arg2 = 0 ;
8566 wxPoint2D *result = 0 ;
8567 void *argp1 = 0 ;
8568 int res1 = 0 ;
8569 wxPoint2D temp2 ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "pt", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8580 }
8581 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8582 {
8583 arg2 = &temp2;
8584 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8585 }
8586 {
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 {
8589 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8590 result = (wxPoint2D *) &_result_ref;
8591 }
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8603 PyObject *resultobj = 0;
8604 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8605 PyObject *arg2 = (PyObject *) 0 ;
8606 bool result;
8607 void *argp1 = 0 ;
8608 int res1 = 0 ;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 char * kwnames[] = {
8612 (char *) "self",(char *) "other", NULL
8613 };
8614
8615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8617 if (!SWIG_IsOK(res1)) {
8618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8619 }
8620 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8621 arg2 = obj1;
8622 {
8623 result = (bool)wxPoint2D___eq__(arg1,arg2);
8624 if (PyErr_Occurred()) SWIG_fail;
8625 }
8626 {
8627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8628 }
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj = 0;
8637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8638 PyObject *arg2 = (PyObject *) 0 ;
8639 bool result;
8640 void *argp1 = 0 ;
8641 int res1 = 0 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "other", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 arg2 = obj1;
8655 {
8656 result = (bool)wxPoint2D___ne__(arg1,arg2);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 {
8660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8661 }
8662 return resultobj;
8663 fail:
8664 return NULL;
8665 }
8666
8667
8668 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8669 PyObject *resultobj = 0;
8670 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8671 double arg2 ;
8672 void *argp1 = 0 ;
8673 int res1 = 0 ;
8674 double val2 ;
8675 int ecode2 = 0 ;
8676 PyObject *swig_obj[2] ;
8677
8678 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8680 if (!SWIG_IsOK(res1)) {
8681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8682 }
8683 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8684 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8685 if (!SWIG_IsOK(ecode2)) {
8686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8687 }
8688 arg2 = static_cast< double >(val2);
8689 if (arg1) (arg1)->m_x = arg2;
8690
8691 resultobj = SWIG_Py_Void();
8692 return resultobj;
8693 fail:
8694 return NULL;
8695 }
8696
8697
8698 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8699 PyObject *resultobj = 0;
8700 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8701 double result;
8702 void *argp1 = 0 ;
8703 int res1 = 0 ;
8704 PyObject *swig_obj[1] ;
8705
8706 if (!args) SWIG_fail;
8707 swig_obj[0] = args;
8708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 result = (double) ((arg1)->m_x);
8714 resultobj = SWIG_From_double(static_cast< double >(result));
8715 return resultobj;
8716 fail:
8717 return NULL;
8718 }
8719
8720
8721 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8722 PyObject *resultobj = 0;
8723 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8724 double arg2 ;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 double val2 ;
8728 int ecode2 = 0 ;
8729 PyObject *swig_obj[2] ;
8730
8731 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8735 }
8736 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8737 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8738 if (!SWIG_IsOK(ecode2)) {
8739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8740 }
8741 arg2 = static_cast< double >(val2);
8742 if (arg1) (arg1)->m_y = arg2;
8743
8744 resultobj = SWIG_Py_Void();
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 double result;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 PyObject *swig_obj[1] ;
8758
8759 if (!args) SWIG_fail;
8760 swig_obj[0] = args;
8761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8764 }
8765 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8766 result = (double) ((arg1)->m_y);
8767 resultobj = SWIG_From_double(static_cast< double >(result));
8768 return resultobj;
8769 fail:
8770 return NULL;
8771 }
8772
8773
8774 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8775 PyObject *resultobj = 0;
8776 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8777 double arg2 = (double) 0 ;
8778 double arg3 = (double) 0 ;
8779 void *argp1 = 0 ;
8780 int res1 = 0 ;
8781 double val2 ;
8782 int ecode2 = 0 ;
8783 double val3 ;
8784 int ecode3 = 0 ;
8785 PyObject * obj0 = 0 ;
8786 PyObject * obj1 = 0 ;
8787 PyObject * obj2 = 0 ;
8788 char * kwnames[] = {
8789 (char *) "self",(char *) "x",(char *) "y", NULL
8790 };
8791
8792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8794 if (!SWIG_IsOK(res1)) {
8795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8796 }
8797 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8798 if (obj1) {
8799 ecode2 = SWIG_AsVal_double(obj1, &val2);
8800 if (!SWIG_IsOK(ecode2)) {
8801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8802 }
8803 arg2 = static_cast< double >(val2);
8804 }
8805 if (obj2) {
8806 ecode3 = SWIG_AsVal_double(obj2, &val3);
8807 if (!SWIG_IsOK(ecode3)) {
8808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8809 }
8810 arg3 = static_cast< double >(val3);
8811 }
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 wxPoint2D_Set(arg1,arg2,arg3);
8815 wxPyEndAllowThreads(__tstate);
8816 if (PyErr_Occurred()) SWIG_fail;
8817 }
8818 resultobj = SWIG_Py_Void();
8819 return resultobj;
8820 fail:
8821 return NULL;
8822 }
8823
8824
8825 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8826 PyObject *resultobj = 0;
8827 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8828 PyObject *result = 0 ;
8829 void *argp1 = 0 ;
8830 int res1 = 0 ;
8831 PyObject *swig_obj[1] ;
8832
8833 if (!args) SWIG_fail;
8834 swig_obj[0] = args;
8835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 {
8841 PyThreadState* __tstate = wxPyBeginAllowThreads();
8842 result = (PyObject *)wxPoint2D_Get(arg1);
8843 wxPyEndAllowThreads(__tstate);
8844 if (PyErr_Occurred()) SWIG_fail;
8845 }
8846 resultobj = result;
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8854 PyObject *obj;
8855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8856 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8857 return SWIG_Py_Void();
8858 }
8859
8860 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8861 return SWIG_Python_InitShadowInstance(args);
8862 }
8863
8864 SWIGINTERN int DefaultPosition_set(PyObject *) {
8865 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8866 return 1;
8867 }
8868
8869
8870 SWIGINTERN PyObject *DefaultPosition_get(void) {
8871 PyObject *pyobj = 0;
8872
8873 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8874 return pyobj;
8875 }
8876
8877
8878 SWIGINTERN int DefaultSize_set(PyObject *) {
8879 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8880 return 1;
8881 }
8882
8883
8884 SWIGINTERN PyObject *DefaultSize_get(void) {
8885 PyObject *pyobj = 0;
8886
8887 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8888 return pyobj;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 PyObject *arg1 = (PyObject *) 0 ;
8895 wxPyInputStream *result = 0 ;
8896 PyObject * obj0 = 0 ;
8897 char * kwnames[] = {
8898 (char *) "p", NULL
8899 };
8900
8901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8902 arg1 = obj0;
8903 {
8904 PyThreadState* __tstate = wxPyBeginAllowThreads();
8905 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8906 wxPyEndAllowThreads(__tstate);
8907 if (PyErr_Occurred()) SWIG_fail;
8908 }
8909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8917 PyObject *resultobj = 0;
8918 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8919 void *argp1 = 0 ;
8920 int res1 = 0 ;
8921 PyObject *swig_obj[1] ;
8922
8923 if (!args) SWIG_fail;
8924 swig_obj[0] = args;
8925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8926 if (!SWIG_IsOK(res1)) {
8927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8928 }
8929 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 delete arg1;
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_Py_Void();
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8945 PyObject *resultobj = 0;
8946 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8947 void *argp1 = 0 ;
8948 int res1 = 0 ;
8949 PyObject *swig_obj[1] ;
8950
8951 if (!args) SWIG_fail;
8952 swig_obj[0] = args;
8953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8954 if (!SWIG_IsOK(res1)) {
8955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8956 }
8957 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8958 {
8959 PyThreadState* __tstate = wxPyBeginAllowThreads();
8960 (arg1)->close();
8961 wxPyEndAllowThreads(__tstate);
8962 if (PyErr_Occurred()) SWIG_fail;
8963 }
8964 resultobj = SWIG_Py_Void();
8965 return resultobj;
8966 fail:
8967 return NULL;
8968 }
8969
8970
8971 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8972 PyObject *resultobj = 0;
8973 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8974 void *argp1 = 0 ;
8975 int res1 = 0 ;
8976 PyObject *swig_obj[1] ;
8977
8978 if (!args) SWIG_fail;
8979 swig_obj[0] = args;
8980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8981 if (!SWIG_IsOK(res1)) {
8982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8983 }
8984 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 (arg1)->flush();
8988 wxPyEndAllowThreads(__tstate);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 resultobj = SWIG_Py_Void();
8992 return resultobj;
8993 fail:
8994 return NULL;
8995 }
8996
8997
8998 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8999 PyObject *resultobj = 0;
9000 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9001 bool result;
9002 void *argp1 = 0 ;
9003 int res1 = 0 ;
9004 PyObject *swig_obj[1] ;
9005
9006 if (!args) SWIG_fail;
9007 swig_obj[0] = args;
9008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9009 if (!SWIG_IsOK(res1)) {
9010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9011 }
9012 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9013 {
9014 PyThreadState* __tstate = wxPyBeginAllowThreads();
9015 result = (bool)(arg1)->eof();
9016 wxPyEndAllowThreads(__tstate);
9017 if (PyErr_Occurred()) SWIG_fail;
9018 }
9019 {
9020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9021 }
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj = 0;
9030 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9031 int arg2 = (int) -1 ;
9032 PyObject *result = 0 ;
9033 void *argp1 = 0 ;
9034 int res1 = 0 ;
9035 int val2 ;
9036 int ecode2 = 0 ;
9037 PyObject * obj0 = 0 ;
9038 PyObject * obj1 = 0 ;
9039 char * kwnames[] = {
9040 (char *) "self",(char *) "size", NULL
9041 };
9042
9043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9045 if (!SWIG_IsOK(res1)) {
9046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9047 }
9048 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9049 if (obj1) {
9050 ecode2 = SWIG_AsVal_int(obj1, &val2);
9051 if (!SWIG_IsOK(ecode2)) {
9052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9053 }
9054 arg2 = static_cast< int >(val2);
9055 }
9056 {
9057 PyThreadState* __tstate = wxPyBeginAllowThreads();
9058 result = (PyObject *)(arg1)->read(arg2);
9059 wxPyEndAllowThreads(__tstate);
9060 if (PyErr_Occurred()) SWIG_fail;
9061 }
9062 resultobj = result;
9063 return resultobj;
9064 fail:
9065 return NULL;
9066 }
9067
9068
9069 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9070 PyObject *resultobj = 0;
9071 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9072 int arg2 = (int) -1 ;
9073 PyObject *result = 0 ;
9074 void *argp1 = 0 ;
9075 int res1 = 0 ;
9076 int val2 ;
9077 int ecode2 = 0 ;
9078 PyObject * obj0 = 0 ;
9079 PyObject * obj1 = 0 ;
9080 char * kwnames[] = {
9081 (char *) "self",(char *) "size", NULL
9082 };
9083
9084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9090 if (obj1) {
9091 ecode2 = SWIG_AsVal_int(obj1, &val2);
9092 if (!SWIG_IsOK(ecode2)) {
9093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9094 }
9095 arg2 = static_cast< int >(val2);
9096 }
9097 {
9098 PyThreadState* __tstate = wxPyBeginAllowThreads();
9099 result = (PyObject *)(arg1)->readline(arg2);
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 resultobj = result;
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj = 0;
9112 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9113 int arg2 = (int) -1 ;
9114 PyObject *result = 0 ;
9115 void *argp1 = 0 ;
9116 int res1 = 0 ;
9117 int val2 ;
9118 int ecode2 = 0 ;
9119 PyObject * obj0 = 0 ;
9120 PyObject * obj1 = 0 ;
9121 char * kwnames[] = {
9122 (char *) "self",(char *) "sizehint", NULL
9123 };
9124
9125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9129 }
9130 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9131 if (obj1) {
9132 ecode2 = SWIG_AsVal_int(obj1, &val2);
9133 if (!SWIG_IsOK(ecode2)) {
9134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9135 }
9136 arg2 = static_cast< int >(val2);
9137 }
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 result = (PyObject *)(arg1)->readlines(arg2);
9141 wxPyEndAllowThreads(__tstate);
9142 if (PyErr_Occurred()) SWIG_fail;
9143 }
9144 resultobj = result;
9145 return resultobj;
9146 fail:
9147 return NULL;
9148 }
9149
9150
9151 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9152 PyObject *resultobj = 0;
9153 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9154 int arg2 ;
9155 int arg3 = (int) 0 ;
9156 void *argp1 = 0 ;
9157 int res1 = 0 ;
9158 int val2 ;
9159 int ecode2 = 0 ;
9160 int val3 ;
9161 int ecode3 = 0 ;
9162 PyObject * obj0 = 0 ;
9163 PyObject * obj1 = 0 ;
9164 PyObject * obj2 = 0 ;
9165 char * kwnames[] = {
9166 (char *) "self",(char *) "offset",(char *) "whence", NULL
9167 };
9168
9169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9171 if (!SWIG_IsOK(res1)) {
9172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9173 }
9174 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9175 ecode2 = SWIG_AsVal_int(obj1, &val2);
9176 if (!SWIG_IsOK(ecode2)) {
9177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9178 }
9179 arg2 = static_cast< int >(val2);
9180 if (obj2) {
9181 ecode3 = SWIG_AsVal_int(obj2, &val3);
9182 if (!SWIG_IsOK(ecode3)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9184 }
9185 arg3 = static_cast< int >(val3);
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 (arg1)->seek(arg2,arg3);
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 resultobj = SWIG_Py_Void();
9194 return resultobj;
9195 fail:
9196 return NULL;
9197 }
9198
9199
9200 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9201 PyObject *resultobj = 0;
9202 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9203 int result;
9204 void *argp1 = 0 ;
9205 int res1 = 0 ;
9206 PyObject *swig_obj[1] ;
9207
9208 if (!args) SWIG_fail;
9209 swig_obj[0] = args;
9210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9211 if (!SWIG_IsOK(res1)) {
9212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9213 }
9214 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9215 {
9216 PyThreadState* __tstate = wxPyBeginAllowThreads();
9217 result = (int)(arg1)->tell();
9218 wxPyEndAllowThreads(__tstate);
9219 if (PyErr_Occurred()) SWIG_fail;
9220 }
9221 resultobj = SWIG_From_int(static_cast< int >(result));
9222 return resultobj;
9223 fail:
9224 return NULL;
9225 }
9226
9227
9228 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 PyObject *resultobj = 0;
9230 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9231 char result;
9232 void *argp1 = 0 ;
9233 int res1 = 0 ;
9234 PyObject *swig_obj[1] ;
9235
9236 if (!args) SWIG_fail;
9237 swig_obj[0] = args;
9238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9239 if (!SWIG_IsOK(res1)) {
9240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9241 }
9242 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (char)(arg1)->Peek();
9246 wxPyEndAllowThreads(__tstate);
9247 if (PyErr_Occurred()) SWIG_fail;
9248 }
9249 resultobj = SWIG_From_char(static_cast< char >(result));
9250 return resultobj;
9251 fail:
9252 return NULL;
9253 }
9254
9255
9256 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9257 PyObject *resultobj = 0;
9258 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9259 char result;
9260 void *argp1 = 0 ;
9261 int res1 = 0 ;
9262 PyObject *swig_obj[1] ;
9263
9264 if (!args) SWIG_fail;
9265 swig_obj[0] = args;
9266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9267 if (!SWIG_IsOK(res1)) {
9268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9269 }
9270 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (char)(arg1)->GetC();
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_From_char(static_cast< char >(result));
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9287 size_t result;
9288 void *argp1 = 0 ;
9289 int res1 = 0 ;
9290 PyObject *swig_obj[1] ;
9291
9292 if (!args) SWIG_fail;
9293 swig_obj[0] = args;
9294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9295 if (!SWIG_IsOK(res1)) {
9296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9297 }
9298 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9299 {
9300 PyThreadState* __tstate = wxPyBeginAllowThreads();
9301 result = (size_t)(arg1)->LastRead();
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9315 bool result;
9316 void *argp1 = 0 ;
9317 int res1 = 0 ;
9318 PyObject *swig_obj[1] ;
9319
9320 if (!args) SWIG_fail;
9321 swig_obj[0] = args;
9322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9323 if (!SWIG_IsOK(res1)) {
9324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9325 }
9326 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9327 {
9328 PyThreadState* __tstate = wxPyBeginAllowThreads();
9329 result = (bool)(arg1)->CanRead();
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 {
9334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9335 }
9336 return resultobj;
9337 fail:
9338 return NULL;
9339 }
9340
9341
9342 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9343 PyObject *resultobj = 0;
9344 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9345 bool result;
9346 void *argp1 = 0 ;
9347 int res1 = 0 ;
9348 PyObject *swig_obj[1] ;
9349
9350 if (!args) SWIG_fail;
9351 swig_obj[0] = args;
9352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9353 if (!SWIG_IsOK(res1)) {
9354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9355 }
9356 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (bool)(arg1)->Eof();
9360 wxPyEndAllowThreads(__tstate);
9361 if (PyErr_Occurred()) SWIG_fail;
9362 }
9363 {
9364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9365 }
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj = 0;
9374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9375 char arg2 ;
9376 bool result;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 char val2 ;
9380 int ecode2 = 0 ;
9381 PyObject * obj0 = 0 ;
9382 PyObject * obj1 = 0 ;
9383 char * kwnames[] = {
9384 (char *) "self",(char *) "c", NULL
9385 };
9386
9387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9389 if (!SWIG_IsOK(res1)) {
9390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9391 }
9392 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9393 ecode2 = SWIG_AsVal_char(obj1, &val2);
9394 if (!SWIG_IsOK(ecode2)) {
9395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9396 }
9397 arg2 = static_cast< char >(val2);
9398 {
9399 PyThreadState* __tstate = wxPyBeginAllowThreads();
9400 result = (bool)(arg1)->Ungetch(arg2);
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 {
9405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9406 }
9407 return resultobj;
9408 fail:
9409 return NULL;
9410 }
9411
9412
9413 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj = 0;
9415 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9416 long arg2 ;
9417 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9418 long result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 long val2 ;
9422 int ecode2 = 0 ;
9423 int val3 ;
9424 int ecode3 = 0 ;
9425 PyObject * obj0 = 0 ;
9426 PyObject * obj1 = 0 ;
9427 PyObject * obj2 = 0 ;
9428 char * kwnames[] = {
9429 (char *) "self",(char *) "pos",(char *) "mode", NULL
9430 };
9431
9432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9434 if (!SWIG_IsOK(res1)) {
9435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9436 }
9437 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9438 ecode2 = SWIG_AsVal_long(obj1, &val2);
9439 if (!SWIG_IsOK(ecode2)) {
9440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9441 }
9442 arg2 = static_cast< long >(val2);
9443 if (obj2) {
9444 ecode3 = SWIG_AsVal_int(obj2, &val3);
9445 if (!SWIG_IsOK(ecode3)) {
9446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9447 }
9448 arg3 = static_cast< wxSeekMode >(val3);
9449 }
9450 {
9451 PyThreadState* __tstate = wxPyBeginAllowThreads();
9452 result = (long)(arg1)->SeekI(arg2,arg3);
9453 wxPyEndAllowThreads(__tstate);
9454 if (PyErr_Occurred()) SWIG_fail;
9455 }
9456 resultobj = SWIG_From_long(static_cast< long >(result));
9457 return resultobj;
9458 fail:
9459 return NULL;
9460 }
9461
9462
9463 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9464 PyObject *resultobj = 0;
9465 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9466 long result;
9467 void *argp1 = 0 ;
9468 int res1 = 0 ;
9469 PyObject *swig_obj[1] ;
9470
9471 if (!args) SWIG_fail;
9472 swig_obj[0] = args;
9473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9474 if (!SWIG_IsOK(res1)) {
9475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9476 }
9477 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9478 {
9479 PyThreadState* __tstate = wxPyBeginAllowThreads();
9480 result = (long)(arg1)->TellI();
9481 wxPyEndAllowThreads(__tstate);
9482 if (PyErr_Occurred()) SWIG_fail;
9483 }
9484 resultobj = SWIG_From_long(static_cast< long >(result));
9485 return resultobj;
9486 fail:
9487 return NULL;
9488 }
9489
9490
9491 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9492 PyObject *obj;
9493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9494 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9495 return SWIG_Py_Void();
9496 }
9497
9498 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9499 return SWIG_Python_InitShadowInstance(args);
9500 }
9501
9502 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9503 PyObject *resultobj = 0;
9504 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9505 PyObject *arg2 = (PyObject *) 0 ;
9506 void *argp1 = 0 ;
9507 int res1 = 0 ;
9508 PyObject * obj0 = 0 ;
9509 PyObject * obj1 = 0 ;
9510 char * kwnames[] = {
9511 (char *) "self",(char *) "obj", NULL
9512 };
9513
9514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9516 if (!SWIG_IsOK(res1)) {
9517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9518 }
9519 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9520 arg2 = obj1;
9521 {
9522 PyThreadState* __tstate = wxPyBeginAllowThreads();
9523 wxOutputStream_write(arg1,arg2);
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 resultobj = SWIG_Py_Void();
9528 return resultobj;
9529 fail:
9530 return NULL;
9531 }
9532
9533
9534 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9535 PyObject *resultobj = 0;
9536 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9537 size_t result;
9538 void *argp1 = 0 ;
9539 int res1 = 0 ;
9540 PyObject *swig_obj[1] ;
9541
9542 if (!args) SWIG_fail;
9543 swig_obj[0] = args;
9544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9545 if (!SWIG_IsOK(res1)) {
9546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9547 }
9548 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9549 {
9550 PyThreadState* __tstate = wxPyBeginAllowThreads();
9551 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9552 wxPyEndAllowThreads(__tstate);
9553 if (PyErr_Occurred()) SWIG_fail;
9554 }
9555 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9556 return resultobj;
9557 fail:
9558 return NULL;
9559 }
9560
9561
9562 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9563 PyObject *obj;
9564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9565 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9566 return SWIG_Py_Void();
9567 }
9568
9569 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9570 PyObject *resultobj = 0;
9571 wxInputStream *arg1 = (wxInputStream *) 0 ;
9572 wxString *arg2 = 0 ;
9573 wxString *arg3 = 0 ;
9574 wxString *arg4 = 0 ;
9575 wxDateTime arg5 ;
9576 wxFSFile *result = 0 ;
9577 wxPyInputStream *temp1 ;
9578 bool temp2 = false ;
9579 bool temp3 = false ;
9580 bool temp4 = false ;
9581 void *argp5 ;
9582 int res5 = 0 ;
9583 PyObject * obj0 = 0 ;
9584 PyObject * obj1 = 0 ;
9585 PyObject * obj2 = 0 ;
9586 PyObject * obj3 = 0 ;
9587 PyObject * obj4 = 0 ;
9588 char * kwnames[] = {
9589 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9590 };
9591
9592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9593 {
9594 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9595 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9596 } else {
9597 PyErr_Clear(); // clear the failure of the wxPyConvert above
9598 arg1 = wxPyCBInputStream_create(obj0, true);
9599 if (arg1 == NULL) {
9600 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9601 SWIG_fail;
9602 }
9603 }
9604 }
9605 {
9606 arg2 = wxString_in_helper(obj1);
9607 if (arg2 == NULL) SWIG_fail;
9608 temp2 = true;
9609 }
9610 {
9611 arg3 = wxString_in_helper(obj2);
9612 if (arg3 == NULL) SWIG_fail;
9613 temp3 = true;
9614 }
9615 {
9616 arg4 = wxString_in_helper(obj3);
9617 if (arg4 == NULL) SWIG_fail;
9618 temp4 = true;
9619 }
9620 {
9621 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9622 if (!SWIG_IsOK(res5)) {
9623 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9624 }
9625 if (!argp5) {
9626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9627 } else {
9628 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9629 arg5 = *temp;
9630 if (SWIG_IsNewObj(res5)) delete temp;
9631 }
9632 }
9633 {
9634 PyThreadState* __tstate = wxPyBeginAllowThreads();
9635 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9636 wxPyEndAllowThreads(__tstate);
9637 if (PyErr_Occurred()) SWIG_fail;
9638 }
9639 {
9640 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9641 }
9642 {
9643 if (temp2)
9644 delete arg2;
9645 }
9646 {
9647 if (temp3)
9648 delete arg3;
9649 }
9650 {
9651 if (temp4)
9652 delete arg4;
9653 }
9654 return resultobj;
9655 fail:
9656 {
9657 if (temp2)
9658 delete arg2;
9659 }
9660 {
9661 if (temp3)
9662 delete arg3;
9663 }
9664 {
9665 if (temp4)
9666 delete arg4;
9667 }
9668 return NULL;
9669 }
9670
9671
9672 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9673 PyObject *resultobj = 0;
9674 wxFSFile *arg1 = (wxFSFile *) 0 ;
9675 void *argp1 = 0 ;
9676 int res1 = 0 ;
9677 PyObject *swig_obj[1] ;
9678
9679 if (!args) SWIG_fail;
9680 swig_obj[0] = args;
9681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9682 if (!SWIG_IsOK(res1)) {
9683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9684 }
9685 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9686 {
9687 PyThreadState* __tstate = wxPyBeginAllowThreads();
9688 delete arg1;
9689
9690 wxPyEndAllowThreads(__tstate);
9691 if (PyErr_Occurred()) SWIG_fail;
9692 }
9693 resultobj = SWIG_Py_Void();
9694 return resultobj;
9695 fail:
9696 return NULL;
9697 }
9698
9699
9700 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9701 PyObject *resultobj = 0;
9702 wxFSFile *arg1 = (wxFSFile *) 0 ;
9703 wxInputStream *result = 0 ;
9704 void *argp1 = 0 ;
9705 int res1 = 0 ;
9706 PyObject *swig_obj[1] ;
9707
9708 if (!args) SWIG_fail;
9709 swig_obj[0] = args;
9710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9711 if (!SWIG_IsOK(res1)) {
9712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9713 }
9714 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9715 {
9716 PyThreadState* __tstate = wxPyBeginAllowThreads();
9717 result = (wxInputStream *)(arg1)->GetStream();
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 wxPyInputStream * _ptr = NULL;
9723
9724 if (result) {
9725 _ptr = new wxPyInputStream(result);
9726 }
9727 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9728 }
9729 return resultobj;
9730 fail:
9731 return NULL;
9732 }
9733
9734
9735 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9736 PyObject *resultobj = 0;
9737 wxFSFile *arg1 = (wxFSFile *) 0 ;
9738 wxString *result = 0 ;
9739 void *argp1 = 0 ;
9740 int res1 = 0 ;
9741 PyObject *swig_obj[1] ;
9742
9743 if (!args) SWIG_fail;
9744 swig_obj[0] = args;
9745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9746 if (!SWIG_IsOK(res1)) {
9747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9748 }
9749 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9750 {
9751 PyThreadState* __tstate = wxPyBeginAllowThreads();
9752 {
9753 wxString const &_result_ref = (arg1)->GetMimeType();
9754 result = (wxString *) &_result_ref;
9755 }
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 #if wxUSE_UNICODE
9761 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9762 #else
9763 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9764 #endif
9765 }
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9773 PyObject *resultobj = 0;
9774 wxFSFile *arg1 = (wxFSFile *) 0 ;
9775 wxString *result = 0 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 PyObject *swig_obj[1] ;
9779
9780 if (!args) SWIG_fail;
9781 swig_obj[0] = args;
9782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9785 }
9786 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9787 {
9788 PyThreadState* __tstate = wxPyBeginAllowThreads();
9789 {
9790 wxString const &_result_ref = (arg1)->GetLocation();
9791 result = (wxString *) &_result_ref;
9792 }
9793 wxPyEndAllowThreads(__tstate);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 {
9797 #if wxUSE_UNICODE
9798 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9799 #else
9800 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9801 #endif
9802 }
9803 return resultobj;
9804 fail:
9805 return NULL;
9806 }
9807
9808
9809 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9810 PyObject *resultobj = 0;
9811 wxFSFile *arg1 = (wxFSFile *) 0 ;
9812 wxString *result = 0 ;
9813 void *argp1 = 0 ;
9814 int res1 = 0 ;
9815 PyObject *swig_obj[1] ;
9816
9817 if (!args) SWIG_fail;
9818 swig_obj[0] = args;
9819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9822 }
9823 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9824 {
9825 PyThreadState* __tstate = wxPyBeginAllowThreads();
9826 {
9827 wxString const &_result_ref = (arg1)->GetAnchor();
9828 result = (wxString *) &_result_ref;
9829 }
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 {
9834 #if wxUSE_UNICODE
9835 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9836 #else
9837 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9838 #endif
9839 }
9840 return resultobj;
9841 fail:
9842 return NULL;
9843 }
9844
9845
9846 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9847 PyObject *resultobj = 0;
9848 wxFSFile *arg1 = (wxFSFile *) 0 ;
9849 wxDateTime result;
9850 void *argp1 = 0 ;
9851 int res1 = 0 ;
9852 PyObject *swig_obj[1] ;
9853
9854 if (!args) SWIG_fail;
9855 swig_obj[0] = args;
9856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9859 }
9860 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9861 {
9862 PyThreadState* __tstate = wxPyBeginAllowThreads();
9863 result = (arg1)->GetModificationTime();
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9868 return resultobj;
9869 fail:
9870 return NULL;
9871 }
9872
9873
9874 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 PyObject *obj;
9876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9877 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9878 return SWIG_Py_Void();
9879 }
9880
9881 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9882 return SWIG_Python_InitShadowInstance(args);
9883 }
9884
9885 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9886 PyObject *resultobj = 0;
9887 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9888 void *argp1 = 0 ;
9889 int res1 = 0 ;
9890 PyObject *swig_obj[1] ;
9891
9892 if (!args) SWIG_fail;
9893 swig_obj[0] = args;
9894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9897 }
9898 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 delete arg1;
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 resultobj = SWIG_Py_Void();
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 PyObject *obj;
9915 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9916 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9917 return SWIG_Py_Void();
9918 }
9919
9920 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9921 PyObject *resultobj = 0;
9922 wxPyFileSystemHandler *result = 0 ;
9923
9924 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9925 {
9926 PyThreadState* __tstate = wxPyBeginAllowThreads();
9927 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9939 PyObject *resultobj = 0;
9940 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9941 PyObject *arg2 = (PyObject *) 0 ;
9942 PyObject *arg3 = (PyObject *) 0 ;
9943 void *argp1 = 0 ;
9944 int res1 = 0 ;
9945 PyObject * obj0 = 0 ;
9946 PyObject * obj1 = 0 ;
9947 PyObject * obj2 = 0 ;
9948 char * kwnames[] = {
9949 (char *) "self",(char *) "self",(char *) "_class", NULL
9950 };
9951
9952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9954 if (!SWIG_IsOK(res1)) {
9955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9956 }
9957 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9958 arg2 = obj1;
9959 arg3 = obj2;
9960 {
9961 PyThreadState* __tstate = wxPyBeginAllowThreads();
9962 (arg1)->_setCallbackInfo(arg2,arg3);
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 resultobj = SWIG_Py_Void();
9967 return resultobj;
9968 fail:
9969 return NULL;
9970 }
9971
9972
9973 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9974 PyObject *resultobj = 0;
9975 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9976 wxString *arg2 = 0 ;
9977 bool result;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 bool temp2 = false ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "location", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9991 }
9992 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9993 {
9994 arg2 = wxString_in_helper(obj1);
9995 if (arg2 == NULL) SWIG_fail;
9996 temp2 = true;
9997 }
9998 {
9999 PyThreadState* __tstate = wxPyBeginAllowThreads();
10000 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10001 wxPyEndAllowThreads(__tstate);
10002 if (PyErr_Occurred()) SWIG_fail;
10003 }
10004 {
10005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10006 }
10007 {
10008 if (temp2)
10009 delete arg2;
10010 }
10011 return resultobj;
10012 fail:
10013 {
10014 if (temp2)
10015 delete arg2;
10016 }
10017 return NULL;
10018 }
10019
10020
10021 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj = 0;
10023 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10024 wxFileSystem *arg2 = 0 ;
10025 wxString *arg3 = 0 ;
10026 wxFSFile *result = 0 ;
10027 void *argp1 = 0 ;
10028 int res1 = 0 ;
10029 void *argp2 = 0 ;
10030 int res2 = 0 ;
10031 bool temp3 = false ;
10032 PyObject * obj0 = 0 ;
10033 PyObject * obj1 = 0 ;
10034 PyObject * obj2 = 0 ;
10035 char * kwnames[] = {
10036 (char *) "self",(char *) "fs",(char *) "location", NULL
10037 };
10038
10039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10041 if (!SWIG_IsOK(res1)) {
10042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10043 }
10044 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10045 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10046 if (!SWIG_IsOK(res2)) {
10047 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10048 }
10049 if (!argp2) {
10050 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10051 }
10052 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10053 {
10054 arg3 = wxString_in_helper(obj2);
10055 if (arg3 == NULL) SWIG_fail;
10056 temp3 = true;
10057 }
10058 {
10059 PyThreadState* __tstate = wxPyBeginAllowThreads();
10060 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10061 wxPyEndAllowThreads(__tstate);
10062 if (PyErr_Occurred()) SWIG_fail;
10063 }
10064 {
10065 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10066 }
10067 {
10068 if (temp3)
10069 delete arg3;
10070 }
10071 return resultobj;
10072 fail:
10073 {
10074 if (temp3)
10075 delete arg3;
10076 }
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10082 PyObject *resultobj = 0;
10083 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10084 wxString *arg2 = 0 ;
10085 int arg3 = (int) 0 ;
10086 wxString result;
10087 void *argp1 = 0 ;
10088 int res1 = 0 ;
10089 bool temp2 = false ;
10090 int val3 ;
10091 int ecode3 = 0 ;
10092 PyObject * obj0 = 0 ;
10093 PyObject * obj1 = 0 ;
10094 PyObject * obj2 = 0 ;
10095 char * kwnames[] = {
10096 (char *) "self",(char *) "spec",(char *) "flags", NULL
10097 };
10098
10099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10101 if (!SWIG_IsOK(res1)) {
10102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10103 }
10104 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10105 {
10106 arg2 = wxString_in_helper(obj1);
10107 if (arg2 == NULL) SWIG_fail;
10108 temp2 = true;
10109 }
10110 if (obj2) {
10111 ecode3 = SWIG_AsVal_int(obj2, &val3);
10112 if (!SWIG_IsOK(ecode3)) {
10113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10114 }
10115 arg3 = static_cast< int >(val3);
10116 }
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10120 wxPyEndAllowThreads(__tstate);
10121 if (PyErr_Occurred()) SWIG_fail;
10122 }
10123 {
10124 #if wxUSE_UNICODE
10125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10126 #else
10127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10128 #endif
10129 }
10130 {
10131 if (temp2)
10132 delete arg2;
10133 }
10134 return resultobj;
10135 fail:
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10147 wxString result;
10148 void *argp1 = 0 ;
10149 int res1 = 0 ;
10150 PyObject *swig_obj[1] ;
10151
10152 if (!args) SWIG_fail;
10153 swig_obj[0] = args;
10154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10157 }
10158 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 result = (arg1)->FindNext();
10162 wxPyEndAllowThreads(__tstate);
10163 if (PyErr_Occurred()) SWIG_fail;
10164 }
10165 {
10166 #if wxUSE_UNICODE
10167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10168 #else
10169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10170 #endif
10171 }
10172 return resultobj;
10173 fail:
10174 return NULL;
10175 }
10176
10177
10178 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10179 PyObject *resultobj = 0;
10180 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10181 wxString *arg2 = 0 ;
10182 wxString result;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 bool temp2 = false ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 char * kwnames[] = {
10189 (char *) "self",(char *) "location", NULL
10190 };
10191
10192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10194 if (!SWIG_IsOK(res1)) {
10195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10196 }
10197 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10198 {
10199 arg2 = wxString_in_helper(obj1);
10200 if (arg2 == NULL) SWIG_fail;
10201 temp2 = true;
10202 }
10203 {
10204 PyThreadState* __tstate = wxPyBeginAllowThreads();
10205 result = (arg1)->GetProtocol((wxString const &)*arg2);
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 {
10210 #if wxUSE_UNICODE
10211 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10212 #else
10213 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10214 #endif
10215 }
10216 {
10217 if (temp2)
10218 delete arg2;
10219 }
10220 return resultobj;
10221 fail:
10222 {
10223 if (temp2)
10224 delete arg2;
10225 }
10226 return NULL;
10227 }
10228
10229
10230 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10231 PyObject *resultobj = 0;
10232 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10233 wxString *arg2 = 0 ;
10234 wxString result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 bool temp2 = false ;
10238 PyObject * obj0 = 0 ;
10239 PyObject * obj1 = 0 ;
10240 char * kwnames[] = {
10241 (char *) "self",(char *) "location", NULL
10242 };
10243
10244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10246 if (!SWIG_IsOK(res1)) {
10247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10248 }
10249 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10250 {
10251 arg2 = wxString_in_helper(obj1);
10252 if (arg2 == NULL) SWIG_fail;
10253 temp2 = true;
10254 }
10255 {
10256 PyThreadState* __tstate = wxPyBeginAllowThreads();
10257 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 {
10262 #if wxUSE_UNICODE
10263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10264 #else
10265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10266 #endif
10267 }
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj = 0;
10284 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10285 wxString *arg2 = 0 ;
10286 wxString result;
10287 void *argp1 = 0 ;
10288 int res1 = 0 ;
10289 bool temp2 = false ;
10290 PyObject * obj0 = 0 ;
10291 PyObject * obj1 = 0 ;
10292 char * kwnames[] = {
10293 (char *) "self",(char *) "location", NULL
10294 };
10295
10296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10298 if (!SWIG_IsOK(res1)) {
10299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10300 }
10301 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10302 {
10303 arg2 = wxString_in_helper(obj1);
10304 if (arg2 == NULL) SWIG_fail;
10305 temp2 = true;
10306 }
10307 {
10308 PyThreadState* __tstate = wxPyBeginAllowThreads();
10309 result = (arg1)->GetAnchor((wxString const &)*arg2);
10310 wxPyEndAllowThreads(__tstate);
10311 if (PyErr_Occurred()) SWIG_fail;
10312 }
10313 {
10314 #if wxUSE_UNICODE
10315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10316 #else
10317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10318 #endif
10319 }
10320 {
10321 if (temp2)
10322 delete arg2;
10323 }
10324 return resultobj;
10325 fail:
10326 {
10327 if (temp2)
10328 delete arg2;
10329 }
10330 return NULL;
10331 }
10332
10333
10334 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj = 0;
10336 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10337 wxString *arg2 = 0 ;
10338 wxString result;
10339 void *argp1 = 0 ;
10340 int res1 = 0 ;
10341 bool temp2 = false ;
10342 PyObject * obj0 = 0 ;
10343 PyObject * obj1 = 0 ;
10344 char * kwnames[] = {
10345 (char *) "self",(char *) "location", NULL
10346 };
10347
10348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10350 if (!SWIG_IsOK(res1)) {
10351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10352 }
10353 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10354 {
10355 arg2 = wxString_in_helper(obj1);
10356 if (arg2 == NULL) SWIG_fail;
10357 temp2 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10362 wxPyEndAllowThreads(__tstate);
10363 if (PyErr_Occurred()) SWIG_fail;
10364 }
10365 {
10366 #if wxUSE_UNICODE
10367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10368 #else
10369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10370 #endif
10371 }
10372 {
10373 if (temp2)
10374 delete arg2;
10375 }
10376 return resultobj;
10377 fail:
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return NULL;
10383 }
10384
10385
10386 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10387 PyObject *resultobj = 0;
10388 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10389 wxString *arg2 = 0 ;
10390 wxString result;
10391 void *argp1 = 0 ;
10392 int res1 = 0 ;
10393 bool temp2 = false ;
10394 PyObject * obj0 = 0 ;
10395 PyObject * obj1 = 0 ;
10396 char * kwnames[] = {
10397 (char *) "self",(char *) "location", NULL
10398 };
10399
10400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10402 if (!SWIG_IsOK(res1)) {
10403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10404 }
10405 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 {
10412 PyThreadState* __tstate = wxPyBeginAllowThreads();
10413 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 {
10418 #if wxUSE_UNICODE
10419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10420 #else
10421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10422 #endif
10423 }
10424 {
10425 if (temp2)
10426 delete arg2;
10427 }
10428 return resultobj;
10429 fail:
10430 {
10431 if (temp2)
10432 delete arg2;
10433 }
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10439 PyObject *obj;
10440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10441 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10442 return SWIG_Py_Void();
10443 }
10444
10445 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10446 return SWIG_Python_InitShadowInstance(args);
10447 }
10448
10449 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10450 PyObject *resultobj = 0;
10451 wxFileSystem *result = 0 ;
10452
10453 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10454 {
10455 PyThreadState* __tstate = wxPyBeginAllowThreads();
10456 result = (wxFileSystem *)new wxFileSystem();
10457 wxPyEndAllowThreads(__tstate);
10458 if (PyErr_Occurred()) SWIG_fail;
10459 }
10460 {
10461 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10462 }
10463 return resultobj;
10464 fail:
10465 return NULL;
10466 }
10467
10468
10469 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10470 PyObject *resultobj = 0;
10471 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10472 void *argp1 = 0 ;
10473 int res1 = 0 ;
10474 PyObject *swig_obj[1] ;
10475
10476 if (!args) SWIG_fail;
10477 swig_obj[0] = args;
10478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10481 }
10482 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10483 {
10484 PyThreadState* __tstate = wxPyBeginAllowThreads();
10485 delete arg1;
10486
10487 wxPyEndAllowThreads(__tstate);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 resultobj = SWIG_Py_Void();
10491 return resultobj;
10492 fail:
10493 return NULL;
10494 }
10495
10496
10497 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10498 PyObject *resultobj = 0;
10499 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10500 wxString *arg2 = 0 ;
10501 bool arg3 = (bool) false ;
10502 void *argp1 = 0 ;
10503 int res1 = 0 ;
10504 bool temp2 = false ;
10505 bool val3 ;
10506 int ecode3 = 0 ;
10507 PyObject * obj0 = 0 ;
10508 PyObject * obj1 = 0 ;
10509 PyObject * obj2 = 0 ;
10510 char * kwnames[] = {
10511 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10512 };
10513
10514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10516 if (!SWIG_IsOK(res1)) {
10517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10518 }
10519 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10520 {
10521 arg2 = wxString_in_helper(obj1);
10522 if (arg2 == NULL) SWIG_fail;
10523 temp2 = true;
10524 }
10525 if (obj2) {
10526 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10527 if (!SWIG_IsOK(ecode3)) {
10528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10529 }
10530 arg3 = static_cast< bool >(val3);
10531 }
10532 {
10533 PyThreadState* __tstate = wxPyBeginAllowThreads();
10534 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10535 wxPyEndAllowThreads(__tstate);
10536 if (PyErr_Occurred()) SWIG_fail;
10537 }
10538 resultobj = SWIG_Py_Void();
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10554 PyObject *resultobj = 0;
10555 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10556 wxString result;
10557 void *argp1 = 0 ;
10558 int res1 = 0 ;
10559 PyObject *swig_obj[1] ;
10560
10561 if (!args) SWIG_fail;
10562 swig_obj[0] = args;
10563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10564 if (!SWIG_IsOK(res1)) {
10565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10566 }
10567 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->GetPath();
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 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj = 0;
10589 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10590 wxString *arg2 = 0 ;
10591 wxFSFile *result = 0 ;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 bool temp2 = false ;
10595 PyObject * obj0 = 0 ;
10596 PyObject * obj1 = 0 ;
10597 char * kwnames[] = {
10598 (char *) "self",(char *) "location", NULL
10599 };
10600
10601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10603 if (!SWIG_IsOK(res1)) {
10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10605 }
10606 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10607 {
10608 arg2 = wxString_in_helper(obj1);
10609 if (arg2 == NULL) SWIG_fail;
10610 temp2 = true;
10611 }
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10620 }
10621 {
10622 if (temp2)
10623 delete arg2;
10624 }
10625 return resultobj;
10626 fail:
10627 {
10628 if (temp2)
10629 delete arg2;
10630 }
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj = 0;
10637 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10638 wxString *arg2 = 0 ;
10639 int arg3 = (int) 0 ;
10640 wxString result;
10641 void *argp1 = 0 ;
10642 int res1 = 0 ;
10643 bool temp2 = false ;
10644 int val3 ;
10645 int ecode3 = 0 ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 PyObject * obj2 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "spec",(char *) "flags", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10657 }
10658 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10659 {
10660 arg2 = wxString_in_helper(obj1);
10661 if (arg2 == NULL) SWIG_fail;
10662 temp2 = true;
10663 }
10664 if (obj2) {
10665 ecode3 = SWIG_AsVal_int(obj2, &val3);
10666 if (!SWIG_IsOK(ecode3)) {
10667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10668 }
10669 arg3 = static_cast< int >(val3);
10670 }
10671 {
10672 PyThreadState* __tstate = wxPyBeginAllowThreads();
10673 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10674 wxPyEndAllowThreads(__tstate);
10675 if (PyErr_Occurred()) SWIG_fail;
10676 }
10677 {
10678 #if wxUSE_UNICODE
10679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10680 #else
10681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10682 #endif
10683 }
10684 {
10685 if (temp2)
10686 delete arg2;
10687 }
10688 return resultobj;
10689 fail:
10690 {
10691 if (temp2)
10692 delete arg2;
10693 }
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10699 PyObject *resultobj = 0;
10700 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10701 wxString result;
10702 void *argp1 = 0 ;
10703 int res1 = 0 ;
10704 PyObject *swig_obj[1] ;
10705
10706 if (!args) SWIG_fail;
10707 swig_obj[0] = args;
10708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10711 }
10712 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10713 {
10714 PyThreadState* __tstate = wxPyBeginAllowThreads();
10715 result = (arg1)->FindNext();
10716 wxPyEndAllowThreads(__tstate);
10717 if (PyErr_Occurred()) SWIG_fail;
10718 }
10719 {
10720 #if wxUSE_UNICODE
10721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10722 #else
10723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10724 #endif
10725 }
10726 return resultobj;
10727 fail:
10728 return NULL;
10729 }
10730
10731
10732 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10733 PyObject *resultobj = 0;
10734 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10735 int res1 = 0 ;
10736 PyObject * obj0 = 0 ;
10737 char * kwnames[] = {
10738 (char *) "handler", NULL
10739 };
10740
10741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10742 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10745 }
10746 {
10747 PyThreadState* __tstate = wxPyBeginAllowThreads();
10748 wxFileSystem::AddHandler(arg1);
10749 wxPyEndAllowThreads(__tstate);
10750 if (PyErr_Occurred()) SWIG_fail;
10751 }
10752 resultobj = SWIG_Py_Void();
10753 return resultobj;
10754 fail:
10755 return NULL;
10756 }
10757
10758
10759 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10760 PyObject *resultobj = 0;
10761
10762 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10763 {
10764 PyThreadState* __tstate = wxPyBeginAllowThreads();
10765 wxFileSystem::CleanUpHandlers();
10766 wxPyEndAllowThreads(__tstate);
10767 if (PyErr_Occurred()) SWIG_fail;
10768 }
10769 resultobj = SWIG_Py_Void();
10770 return resultobj;
10771 fail:
10772 return NULL;
10773 }
10774
10775
10776 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10777 PyObject *resultobj = 0;
10778 wxString *arg1 = 0 ;
10779 wxString result;
10780 bool temp1 = false ;
10781 PyObject * obj0 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "filename", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10787 {
10788 arg1 = wxString_in_helper(obj0);
10789 if (arg1 == NULL) SWIG_fail;
10790 temp1 = true;
10791 }
10792 {
10793 PyThreadState* __tstate = wxPyBeginAllowThreads();
10794 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10795 wxPyEndAllowThreads(__tstate);
10796 if (PyErr_Occurred()) SWIG_fail;
10797 }
10798 {
10799 #if wxUSE_UNICODE
10800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10801 #else
10802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10803 #endif
10804 }
10805 {
10806 if (temp1)
10807 delete arg1;
10808 }
10809 return resultobj;
10810 fail:
10811 {
10812 if (temp1)
10813 delete arg1;
10814 }
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxString *arg1 = 0 ;
10822 wxString result;
10823 bool temp1 = false ;
10824 PyObject * obj0 = 0 ;
10825 char * kwnames[] = {
10826 (char *) "url", NULL
10827 };
10828
10829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10830 {
10831 arg1 = wxString_in_helper(obj0);
10832 if (arg1 == NULL) SWIG_fail;
10833 temp1 = true;
10834 }
10835 {
10836 PyThreadState* __tstate = wxPyBeginAllowThreads();
10837 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 {
10842 #if wxUSE_UNICODE
10843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10844 #else
10845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10846 #endif
10847 }
10848 {
10849 if (temp1)
10850 delete arg1;
10851 }
10852 return resultobj;
10853 fail:
10854 {
10855 if (temp1)
10856 delete arg1;
10857 }
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10863 PyObject *obj;
10864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10865 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10866 return SWIG_Py_Void();
10867 }
10868
10869 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10870 return SWIG_Python_InitShadowInstance(args);
10871 }
10872
10873 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10874 PyObject *resultobj = 0;
10875 wxInternetFSHandler *result = 0 ;
10876
10877 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10878 {
10879 PyThreadState* __tstate = wxPyBeginAllowThreads();
10880 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10881 wxPyEndAllowThreads(__tstate);
10882 if (PyErr_Occurred()) SWIG_fail;
10883 }
10884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10892 PyObject *resultobj = 0;
10893 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10894 wxString *arg2 = 0 ;
10895 bool result;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 bool temp2 = false ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 char * kwnames[] = {
10902 (char *) "self",(char *) "location", NULL
10903 };
10904
10905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10907 if (!SWIG_IsOK(res1)) {
10908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10909 }
10910 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10911 {
10912 arg2 = wxString_in_helper(obj1);
10913 if (arg2 == NULL) SWIG_fail;
10914 temp2 = true;
10915 }
10916 {
10917 PyThreadState* __tstate = wxPyBeginAllowThreads();
10918 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 {
10923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10924 }
10925 {
10926 if (temp2)
10927 delete arg2;
10928 }
10929 return resultobj;
10930 fail:
10931 {
10932 if (temp2)
10933 delete arg2;
10934 }
10935 return NULL;
10936 }
10937
10938
10939 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj = 0;
10941 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10942 wxFileSystem *arg2 = 0 ;
10943 wxString *arg3 = 0 ;
10944 wxFSFile *result = 0 ;
10945 void *argp1 = 0 ;
10946 int res1 = 0 ;
10947 void *argp2 = 0 ;
10948 int res2 = 0 ;
10949 bool temp3 = false ;
10950 PyObject * obj0 = 0 ;
10951 PyObject * obj1 = 0 ;
10952 PyObject * obj2 = 0 ;
10953 char * kwnames[] = {
10954 (char *) "self",(char *) "fs",(char *) "location", NULL
10955 };
10956
10957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10959 if (!SWIG_IsOK(res1)) {
10960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10961 }
10962 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10963 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10964 if (!SWIG_IsOK(res2)) {
10965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10966 }
10967 if (!argp2) {
10968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10969 }
10970 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10971 {
10972 arg3 = wxString_in_helper(obj2);
10973 if (arg3 == NULL) SWIG_fail;
10974 temp3 = true;
10975 }
10976 {
10977 PyThreadState* __tstate = wxPyBeginAllowThreads();
10978 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10979 wxPyEndAllowThreads(__tstate);
10980 if (PyErr_Occurred()) SWIG_fail;
10981 }
10982 {
10983 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10984 }
10985 {
10986 if (temp3)
10987 delete arg3;
10988 }
10989 return resultobj;
10990 fail:
10991 {
10992 if (temp3)
10993 delete arg3;
10994 }
10995 return NULL;
10996 }
10997
10998
10999 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11000 PyObject *obj;
11001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11002 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11003 return SWIG_Py_Void();
11004 }
11005
11006 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11007 return SWIG_Python_InitShadowInstance(args);
11008 }
11009
11010 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11011 PyObject *resultobj = 0;
11012 wxZipFSHandler *result = 0 ;
11013
11014 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11015 {
11016 PyThreadState* __tstate = wxPyBeginAllowThreads();
11017 result = (wxZipFSHandler *)new wxZipFSHandler();
11018 wxPyEndAllowThreads(__tstate);
11019 if (PyErr_Occurred()) SWIG_fail;
11020 }
11021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11022 return resultobj;
11023 fail:
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11031 wxString *arg2 = 0 ;
11032 bool result;
11033 void *argp1 = 0 ;
11034 int res1 = 0 ;
11035 bool temp2 = false ;
11036 PyObject * obj0 = 0 ;
11037 PyObject * obj1 = 0 ;
11038 char * kwnames[] = {
11039 (char *) "self",(char *) "location", NULL
11040 };
11041
11042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11044 if (!SWIG_IsOK(res1)) {
11045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11046 }
11047 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11048 {
11049 arg2 = wxString_in_helper(obj1);
11050 if (arg2 == NULL) SWIG_fail;
11051 temp2 = true;
11052 }
11053 {
11054 PyThreadState* __tstate = wxPyBeginAllowThreads();
11055 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11056 wxPyEndAllowThreads(__tstate);
11057 if (PyErr_Occurred()) SWIG_fail;
11058 }
11059 {
11060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11061 }
11062 {
11063 if (temp2)
11064 delete arg2;
11065 }
11066 return resultobj;
11067 fail:
11068 {
11069 if (temp2)
11070 delete arg2;
11071 }
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11077 PyObject *resultobj = 0;
11078 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11079 wxFileSystem *arg2 = 0 ;
11080 wxString *arg3 = 0 ;
11081 wxFSFile *result = 0 ;
11082 void *argp1 = 0 ;
11083 int res1 = 0 ;
11084 void *argp2 = 0 ;
11085 int res2 = 0 ;
11086 bool temp3 = false ;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 PyObject * obj2 = 0 ;
11090 char * kwnames[] = {
11091 (char *) "self",(char *) "fs",(char *) "location", NULL
11092 };
11093
11094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11096 if (!SWIG_IsOK(res1)) {
11097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11098 }
11099 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11100 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11101 if (!SWIG_IsOK(res2)) {
11102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11103 }
11104 if (!argp2) {
11105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11106 }
11107 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11108 {
11109 arg3 = wxString_in_helper(obj2);
11110 if (arg3 == NULL) SWIG_fail;
11111 temp3 = true;
11112 }
11113 {
11114 PyThreadState* __tstate = wxPyBeginAllowThreads();
11115 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11116 wxPyEndAllowThreads(__tstate);
11117 if (PyErr_Occurred()) SWIG_fail;
11118 }
11119 {
11120 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11121 }
11122 {
11123 if (temp3)
11124 delete arg3;
11125 }
11126 return resultobj;
11127 fail:
11128 {
11129 if (temp3)
11130 delete arg3;
11131 }
11132 return NULL;
11133 }
11134
11135
11136 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11137 PyObject *resultobj = 0;
11138 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11139 wxString *arg2 = 0 ;
11140 int arg3 = (int) 0 ;
11141 wxString result;
11142 void *argp1 = 0 ;
11143 int res1 = 0 ;
11144 bool temp2 = false ;
11145 int val3 ;
11146 int ecode3 = 0 ;
11147 PyObject * obj0 = 0 ;
11148 PyObject * obj1 = 0 ;
11149 PyObject * obj2 = 0 ;
11150 char * kwnames[] = {
11151 (char *) "self",(char *) "spec",(char *) "flags", NULL
11152 };
11153
11154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11156 if (!SWIG_IsOK(res1)) {
11157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11158 }
11159 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11160 {
11161 arg2 = wxString_in_helper(obj1);
11162 if (arg2 == NULL) SWIG_fail;
11163 temp2 = true;
11164 }
11165 if (obj2) {
11166 ecode3 = SWIG_AsVal_int(obj2, &val3);
11167 if (!SWIG_IsOK(ecode3)) {
11168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11169 }
11170 arg3 = static_cast< int >(val3);
11171 }
11172 {
11173 PyThreadState* __tstate = wxPyBeginAllowThreads();
11174 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 {
11179 #if wxUSE_UNICODE
11180 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11181 #else
11182 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11183 #endif
11184 }
11185 {
11186 if (temp2)
11187 delete arg2;
11188 }
11189 return resultobj;
11190 fail:
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11200 PyObject *resultobj = 0;
11201 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11202 wxString result;
11203 void *argp1 = 0 ;
11204 int res1 = 0 ;
11205 PyObject *swig_obj[1] ;
11206
11207 if (!args) SWIG_fail;
11208 swig_obj[0] = args;
11209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11210 if (!SWIG_IsOK(res1)) {
11211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11212 }
11213 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11214 {
11215 PyThreadState* __tstate = wxPyBeginAllowThreads();
11216 result = (arg1)->FindNext();
11217 wxPyEndAllowThreads(__tstate);
11218 if (PyErr_Occurred()) SWIG_fail;
11219 }
11220 {
11221 #if wxUSE_UNICODE
11222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11223 #else
11224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11225 #endif
11226 }
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11234 PyObject *obj;
11235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11236 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11237 return SWIG_Py_Void();
11238 }
11239
11240 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11241 return SWIG_Python_InitShadowInstance(args);
11242 }
11243
11244 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj = 0;
11246 wxString *arg1 = 0 ;
11247 wxImage *arg2 = 0 ;
11248 long arg3 ;
11249 bool temp1 = false ;
11250 void *argp2 = 0 ;
11251 int res2 = 0 ;
11252 long val3 ;
11253 int ecode3 = 0 ;
11254 PyObject * obj0 = 0 ;
11255 PyObject * obj1 = 0 ;
11256 PyObject * obj2 = 0 ;
11257 char * kwnames[] = {
11258 (char *) "filename",(char *) "image",(char *) "type", NULL
11259 };
11260
11261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11262 {
11263 arg1 = wxString_in_helper(obj0);
11264 if (arg1 == NULL) SWIG_fail;
11265 temp1 = true;
11266 }
11267 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11268 if (!SWIG_IsOK(res2)) {
11269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11270 }
11271 if (!argp2) {
11272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11273 }
11274 arg2 = reinterpret_cast< wxImage * >(argp2);
11275 ecode3 = SWIG_AsVal_long(obj2, &val3);
11276 if (!SWIG_IsOK(ecode3)) {
11277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11278 }
11279 arg3 = static_cast< long >(val3);
11280 {
11281 PyThreadState* __tstate = wxPyBeginAllowThreads();
11282 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11283 wxPyEndAllowThreads(__tstate);
11284 if (PyErr_Occurred()) SWIG_fail;
11285 }
11286 resultobj = SWIG_Py_Void();
11287 {
11288 if (temp1)
11289 delete arg1;
11290 }
11291 return resultobj;
11292 fail:
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11302 PyObject *resultobj = 0;
11303 wxString *arg1 = 0 ;
11304 wxBitmap *arg2 = 0 ;
11305 long arg3 ;
11306 bool temp1 = false ;
11307 void *argp2 = 0 ;
11308 int res2 = 0 ;
11309 long val3 ;
11310 int ecode3 = 0 ;
11311 PyObject * obj0 = 0 ;
11312 PyObject * obj1 = 0 ;
11313 PyObject * obj2 = 0 ;
11314 char * kwnames[] = {
11315 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11316 };
11317
11318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11319 {
11320 arg1 = wxString_in_helper(obj0);
11321 if (arg1 == NULL) SWIG_fail;
11322 temp1 = true;
11323 }
11324 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11325 if (!SWIG_IsOK(res2)) {
11326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11327 }
11328 if (!argp2) {
11329 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11330 }
11331 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11332 ecode3 = SWIG_AsVal_long(obj2, &val3);
11333 if (!SWIG_IsOK(ecode3)) {
11334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11335 }
11336 arg3 = static_cast< long >(val3);
11337 {
11338 PyThreadState* __tstate = wxPyBeginAllowThreads();
11339 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11340 wxPyEndAllowThreads(__tstate);
11341 if (PyErr_Occurred()) SWIG_fail;
11342 }
11343 resultobj = SWIG_Py_Void();
11344 {
11345 if (temp1)
11346 delete arg1;
11347 }
11348 return resultobj;
11349 fail:
11350 {
11351 if (temp1)
11352 delete arg1;
11353 }
11354 return NULL;
11355 }
11356
11357
11358 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = 0;
11360 wxString *arg1 = 0 ;
11361 PyObject *arg2 = (PyObject *) 0 ;
11362 bool temp1 = false ;
11363 PyObject * obj0 = 0 ;
11364 PyObject * obj1 = 0 ;
11365 char * kwnames[] = {
11366 (char *) "filename",(char *) "data", NULL
11367 };
11368
11369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11370 {
11371 arg1 = wxString_in_helper(obj0);
11372 if (arg1 == NULL) SWIG_fail;
11373 temp1 = true;
11374 }
11375 arg2 = obj1;
11376 {
11377 PyThreadState* __tstate = wxPyBeginAllowThreads();
11378 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11379 wxPyEndAllowThreads(__tstate);
11380 if (PyErr_Occurred()) SWIG_fail;
11381 }
11382 resultobj = SWIG_Py_Void();
11383 {
11384 if (temp1)
11385 delete arg1;
11386 }
11387 return resultobj;
11388 fail:
11389 {
11390 if (temp1)
11391 delete arg1;
11392 }
11393 return NULL;
11394 }
11395
11396
11397 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11398 PyObject *resultobj = 0;
11399 wxMemoryFSHandler *result = 0 ;
11400
11401 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11409 return resultobj;
11410 fail:
11411 return NULL;
11412 }
11413
11414
11415 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj = 0;
11417 wxString *arg1 = 0 ;
11418 bool temp1 = false ;
11419 PyObject * obj0 = 0 ;
11420 char * kwnames[] = {
11421 (char *) "filename", NULL
11422 };
11423
11424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11425 {
11426 arg1 = wxString_in_helper(obj0);
11427 if (arg1 == NULL) SWIG_fail;
11428 temp1 = true;
11429 }
11430 {
11431 PyThreadState* __tstate = wxPyBeginAllowThreads();
11432 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11433 wxPyEndAllowThreads(__tstate);
11434 if (PyErr_Occurred()) SWIG_fail;
11435 }
11436 resultobj = SWIG_Py_Void();
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj = 0;
11453 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11454 wxString *arg2 = 0 ;
11455 bool result;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 bool temp2 = false ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char * kwnames[] = {
11462 (char *) "self",(char *) "location", NULL
11463 };
11464
11465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11467 if (!SWIG_IsOK(res1)) {
11468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11469 }
11470 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11471 {
11472 arg2 = wxString_in_helper(obj1);
11473 if (arg2 == NULL) SWIG_fail;
11474 temp2 = true;
11475 }
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11484 }
11485 {
11486 if (temp2)
11487 delete arg2;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp2)
11493 delete arg2;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj = 0;
11501 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11502 wxFileSystem *arg2 = 0 ;
11503 wxString *arg3 = 0 ;
11504 wxFSFile *result = 0 ;
11505 void *argp1 = 0 ;
11506 int res1 = 0 ;
11507 void *argp2 = 0 ;
11508 int res2 = 0 ;
11509 bool temp3 = false ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 PyObject * obj2 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "fs",(char *) "location", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11521 }
11522 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11524 if (!SWIG_IsOK(res2)) {
11525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11526 }
11527 if (!argp2) {
11528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11529 }
11530 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11531 {
11532 arg3 = wxString_in_helper(obj2);
11533 if (arg3 == NULL) SWIG_fail;
11534 temp3 = true;
11535 }
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11544 }
11545 {
11546 if (temp3)
11547 delete arg3;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp3)
11553 delete arg3;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = 0;
11561 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11562 wxString *arg2 = 0 ;
11563 int arg3 = (int) 0 ;
11564 wxString result;
11565 void *argp1 = 0 ;
11566 int res1 = 0 ;
11567 bool temp2 = false ;
11568 int val3 ;
11569 int ecode3 = 0 ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 char * kwnames[] = {
11574 (char *) "self",(char *) "spec",(char *) "flags", NULL
11575 };
11576
11577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11581 }
11582 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11583 {
11584 arg2 = wxString_in_helper(obj1);
11585 if (arg2 == NULL) SWIG_fail;
11586 temp2 = true;
11587 }
11588 if (obj2) {
11589 ecode3 = SWIG_AsVal_int(obj2, &val3);
11590 if (!SWIG_IsOK(ecode3)) {
11591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11592 }
11593 arg3 = static_cast< int >(val3);
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 {
11602 #if wxUSE_UNICODE
11603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11604 #else
11605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11606 #endif
11607 }
11608 {
11609 if (temp2)
11610 delete arg2;
11611 }
11612 return resultobj;
11613 fail:
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11625 wxString result;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11635 }
11636 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (arg1)->FindNext();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 {
11644 #if wxUSE_UNICODE
11645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11646 #else
11647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11648 #endif
11649 }
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 PyObject *obj;
11658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11660 return SWIG_Py_Void();
11661 }
11662
11663 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 return SWIG_Python_InitShadowInstance(args);
11665 }
11666
11667 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11668 PyObject *resultobj = 0;
11669 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11670 wxString result;
11671 void *argp1 = 0 ;
11672 int res1 = 0 ;
11673 PyObject *swig_obj[1] ;
11674
11675 if (!args) SWIG_fail;
11676 swig_obj[0] = args;
11677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11678 if (!SWIG_IsOK(res1)) {
11679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11680 }
11681 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11682 {
11683 PyThreadState* __tstate = wxPyBeginAllowThreads();
11684 result = (arg1)->GetName();
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 #if wxUSE_UNICODE
11690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11691 #else
11692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11693 #endif
11694 }
11695 return resultobj;
11696 fail:
11697 return NULL;
11698 }
11699
11700
11701 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11702 PyObject *resultobj = 0;
11703 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11704 wxString result;
11705 void *argp1 = 0 ;
11706 int res1 = 0 ;
11707 PyObject *swig_obj[1] ;
11708
11709 if (!args) SWIG_fail;
11710 swig_obj[0] = args;
11711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11712 if (!SWIG_IsOK(res1)) {
11713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11714 }
11715 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 result = (arg1)->GetExtension();
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 {
11723 #if wxUSE_UNICODE
11724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11725 #else
11726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11727 #endif
11728 }
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11738 long result;
11739 void *argp1 = 0 ;
11740 int res1 = 0 ;
11741 PyObject *swig_obj[1] ;
11742
11743 if (!args) SWIG_fail;
11744 swig_obj[0] = args;
11745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11746 if (!SWIG_IsOK(res1)) {
11747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11748 }
11749 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 result = (long)(arg1)->GetType();
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 resultobj = SWIG_From_long(static_cast< long >(result));
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *resultobj = 0;
11765 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11766 wxString result;
11767 void *argp1 = 0 ;
11768 int res1 = 0 ;
11769 PyObject *swig_obj[1] ;
11770
11771 if (!args) SWIG_fail;
11772 swig_obj[0] = args;
11773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11774 if (!SWIG_IsOK(res1)) {
11775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11776 }
11777 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11778 {
11779 PyThreadState* __tstate = wxPyBeginAllowThreads();
11780 result = (arg1)->GetMimeType();
11781 wxPyEndAllowThreads(__tstate);
11782 if (PyErr_Occurred()) SWIG_fail;
11783 }
11784 {
11785 #if wxUSE_UNICODE
11786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11787 #else
11788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11789 #endif
11790 }
11791 return resultobj;
11792 fail:
11793 return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11798 PyObject *resultobj = 0;
11799 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11800 wxString *arg2 = 0 ;
11801 bool result;
11802 void *argp1 = 0 ;
11803 int res1 = 0 ;
11804 bool temp2 = false ;
11805 PyObject * obj0 = 0 ;
11806 PyObject * obj1 = 0 ;
11807 char * kwnames[] = {
11808 (char *) "self",(char *) "name", NULL
11809 };
11810
11811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11813 if (!SWIG_IsOK(res1)) {
11814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11815 }
11816 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11817 {
11818 arg2 = wxString_in_helper(obj1);
11819 if (arg2 == NULL) SWIG_fail;
11820 temp2 = true;
11821 }
11822 {
11823 PyThreadState* __tstate = wxPyBeginAllowThreads();
11824 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 {
11829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11830 }
11831 {
11832 if (temp2)
11833 delete arg2;
11834 }
11835 return resultobj;
11836 fail:
11837 {
11838 if (temp2)
11839 delete arg2;
11840 }
11841 return NULL;
11842 }
11843
11844
11845 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11846 PyObject *resultobj = 0;
11847 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11848 wxString *arg2 = 0 ;
11849 void *argp1 = 0 ;
11850 int res1 = 0 ;
11851 bool temp2 = false ;
11852 PyObject * obj0 = 0 ;
11853 PyObject * obj1 = 0 ;
11854 char * kwnames[] = {
11855 (char *) "self",(char *) "name", NULL
11856 };
11857
11858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11862 }
11863 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11864 {
11865 arg2 = wxString_in_helper(obj1);
11866 if (arg2 == NULL) SWIG_fail;
11867 temp2 = true;
11868 }
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 (arg1)->SetName((wxString const &)*arg2);
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 resultobj = SWIG_Py_Void();
11876 {
11877 if (temp2)
11878 delete arg2;
11879 }
11880 return resultobj;
11881 fail:
11882 {
11883 if (temp2)
11884 delete arg2;
11885 }
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11893 wxString *arg2 = 0 ;
11894 void *argp1 = 0 ;
11895 int res1 = 0 ;
11896 bool temp2 = false ;
11897 PyObject * obj0 = 0 ;
11898 PyObject * obj1 = 0 ;
11899 char * kwnames[] = {
11900 (char *) "self",(char *) "extension", NULL
11901 };
11902
11903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11905 if (!SWIG_IsOK(res1)) {
11906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11907 }
11908 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11909 {
11910 arg2 = wxString_in_helper(obj1);
11911 if (arg2 == NULL) SWIG_fail;
11912 temp2 = true;
11913 }
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 (arg1)->SetExtension((wxString const &)*arg2);
11917 wxPyEndAllowThreads(__tstate);
11918 if (PyErr_Occurred()) SWIG_fail;
11919 }
11920 resultobj = SWIG_Py_Void();
11921 {
11922 if (temp2)
11923 delete arg2;
11924 }
11925 return resultobj;
11926 fail:
11927 {
11928 if (temp2)
11929 delete arg2;
11930 }
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11938 long arg2 ;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 long val2 ;
11942 int ecode2 = 0 ;
11943 PyObject * obj0 = 0 ;
11944 PyObject * obj1 = 0 ;
11945 char * kwnames[] = {
11946 (char *) "self",(char *) "type", NULL
11947 };
11948
11949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11951 if (!SWIG_IsOK(res1)) {
11952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11953 }
11954 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11955 ecode2 = SWIG_AsVal_long(obj1, &val2);
11956 if (!SWIG_IsOK(ecode2)) {
11957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11958 }
11959 arg2 = static_cast< long >(val2);
11960 {
11961 PyThreadState* __tstate = wxPyBeginAllowThreads();
11962 (arg1)->SetType(arg2);
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 resultobj = SWIG_Py_Void();
11967 return resultobj;
11968 fail:
11969 return NULL;
11970 }
11971
11972
11973 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11974 PyObject *resultobj = 0;
11975 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11976 wxString *arg2 = 0 ;
11977 void *argp1 = 0 ;
11978 int res1 = 0 ;
11979 bool temp2 = false ;
11980 PyObject * obj0 = 0 ;
11981 PyObject * obj1 = 0 ;
11982 char * kwnames[] = {
11983 (char *) "self",(char *) "mimetype", NULL
11984 };
11985
11986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11990 }
11991 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11992 {
11993 arg2 = wxString_in_helper(obj1);
11994 if (arg2 == NULL) SWIG_fail;
11995 temp2 = true;
11996 }
11997 {
11998 PyThreadState* __tstate = wxPyBeginAllowThreads();
11999 (arg1)->SetMimeType((wxString const &)*arg2);
12000 wxPyEndAllowThreads(__tstate);
12001 if (PyErr_Occurred()) SWIG_fail;
12002 }
12003 resultobj = SWIG_Py_Void();
12004 {
12005 if (temp2)
12006 delete arg2;
12007 }
12008 return resultobj;
12009 fail:
12010 {
12011 if (temp2)
12012 delete arg2;
12013 }
12014 return NULL;
12015 }
12016
12017
12018 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12019 PyObject *obj;
12020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12021 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12022 return SWIG_Py_Void();
12023 }
12024
12025 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12026 PyObject *resultobj = 0;
12027 wxPyImageHandler *result = 0 ;
12028
12029 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (wxPyImageHandler *)new wxPyImageHandler();
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12037 return resultobj;
12038 fail:
12039 return NULL;
12040 }
12041
12042
12043 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12044 PyObject *resultobj = 0;
12045 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12046 PyObject *arg2 = (PyObject *) 0 ;
12047 void *argp1 = 0 ;
12048 int res1 = 0 ;
12049 PyObject * obj0 = 0 ;
12050 PyObject * obj1 = 0 ;
12051 char * kwnames[] = {
12052 (char *) "self",(char *) "self", NULL
12053 };
12054
12055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12057 if (!SWIG_IsOK(res1)) {
12058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12059 }
12060 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12061 arg2 = obj1;
12062 {
12063 PyThreadState* __tstate = wxPyBeginAllowThreads();
12064 (arg1)->_SetSelf(arg2);
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 resultobj = SWIG_Py_Void();
12069 return resultobj;
12070 fail:
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12076 PyObject *obj;
12077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12079 return SWIG_Py_Void();
12080 }
12081
12082 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12083 return SWIG_Python_InitShadowInstance(args);
12084 }
12085
12086 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 PyObject *resultobj = 0;
12088 wxImageHistogram *result = 0 ;
12089
12090 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12091 {
12092 PyThreadState* __tstate = wxPyBeginAllowThreads();
12093 result = (wxImageHistogram *)new wxImageHistogram();
12094 wxPyEndAllowThreads(__tstate);
12095 if (PyErr_Occurred()) SWIG_fail;
12096 }
12097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj = 0;
12106 byte arg1 ;
12107 byte arg2 ;
12108 byte arg3 ;
12109 unsigned long result;
12110 unsigned char val1 ;
12111 int ecode1 = 0 ;
12112 unsigned char val2 ;
12113 int ecode2 = 0 ;
12114 unsigned char val3 ;
12115 int ecode3 = 0 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 PyObject * obj2 = 0 ;
12119 char * kwnames[] = {
12120 (char *) "r",(char *) "g",(char *) "b", NULL
12121 };
12122
12123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12124 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12125 if (!SWIG_IsOK(ecode1)) {
12126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12127 }
12128 arg1 = static_cast< byte >(val1);
12129 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12130 if (!SWIG_IsOK(ecode2)) {
12131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12132 }
12133 arg2 = static_cast< byte >(val2);
12134 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12135 if (!SWIG_IsOK(ecode3)) {
12136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12137 }
12138 arg3 = static_cast< byte >(val3);
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj = 0;
12154 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12155 byte *arg2 = (byte *) 0 ;
12156 byte *arg3 = (byte *) 0 ;
12157 byte *arg4 = (byte *) 0 ;
12158 byte arg5 = (byte) 1 ;
12159 byte arg6 = (byte) 0 ;
12160 byte arg7 = (byte) 0 ;
12161 bool result;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 byte temp2 ;
12165 int res2 = SWIG_TMPOBJ ;
12166 byte temp3 ;
12167 int res3 = SWIG_TMPOBJ ;
12168 byte temp4 ;
12169 int res4 = SWIG_TMPOBJ ;
12170 unsigned char val5 ;
12171 int ecode5 = 0 ;
12172 unsigned char val6 ;
12173 int ecode6 = 0 ;
12174 unsigned char val7 ;
12175 int ecode7 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 PyObject * obj3 = 0 ;
12180 char * kwnames[] = {
12181 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12182 };
12183
12184 arg2 = &temp2;
12185 arg3 = &temp3;
12186 arg4 = &temp4;
12187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12189 if (!SWIG_IsOK(res1)) {
12190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12191 }
12192 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12193 if (obj1) {
12194 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12195 if (!SWIG_IsOK(ecode5)) {
12196 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12197 }
12198 arg5 = static_cast< byte >(val5);
12199 }
12200 if (obj2) {
12201 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12202 if (!SWIG_IsOK(ecode6)) {
12203 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12204 }
12205 arg6 = static_cast< byte >(val6);
12206 }
12207 if (obj3) {
12208 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12209 if (!SWIG_IsOK(ecode7)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12211 }
12212 arg7 = static_cast< byte >(val7);
12213 }
12214 {
12215 PyThreadState* __tstate = wxPyBeginAllowThreads();
12216 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12217 wxPyEndAllowThreads(__tstate);
12218 if (PyErr_Occurred()) SWIG_fail;
12219 }
12220 {
12221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12222 }
12223 if (SWIG_IsTmpObj(res2)) {
12224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12225 } else {
12226 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12228 }
12229 if (SWIG_IsTmpObj(res3)) {
12230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12231 } else {
12232 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12234 }
12235 if (SWIG_IsTmpObj(res4)) {
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12237 } else {
12238 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12240 }
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj = 0;
12249 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12250 unsigned long arg2 ;
12251 unsigned long result;
12252 void *argp1 = 0 ;
12253 int res1 = 0 ;
12254 unsigned long val2 ;
12255 int ecode2 = 0 ;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 char * kwnames[] = {
12259 (char *) "self",(char *) "key", NULL
12260 };
12261
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12264 if (!SWIG_IsOK(res1)) {
12265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12266 }
12267 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12268 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12269 if (!SWIG_IsOK(ecode2)) {
12270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12271 }
12272 arg2 = static_cast< unsigned long >(val2);
12273 {
12274 PyThreadState* __tstate = wxPyBeginAllowThreads();
12275 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12280 return resultobj;
12281 fail:
12282 return NULL;
12283 }
12284
12285
12286 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12287 PyObject *resultobj = 0;
12288 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12289 byte arg2 ;
12290 byte arg3 ;
12291 byte arg4 ;
12292 unsigned long result;
12293 void *argp1 = 0 ;
12294 int res1 = 0 ;
12295 unsigned char val2 ;
12296 int ecode2 = 0 ;
12297 unsigned char val3 ;
12298 int ecode3 = 0 ;
12299 unsigned char val4 ;
12300 int ecode4 = 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 PyObject * obj2 = 0 ;
12304 PyObject * obj3 = 0 ;
12305 char * kwnames[] = {
12306 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12307 };
12308
12309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12311 if (!SWIG_IsOK(res1)) {
12312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12313 }
12314 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12316 if (!SWIG_IsOK(ecode2)) {
12317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12318 }
12319 arg2 = static_cast< byte >(val2);
12320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12321 if (!SWIG_IsOK(ecode3)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12323 }
12324 arg3 = static_cast< byte >(val3);
12325 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12326 if (!SWIG_IsOK(ecode4)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12328 }
12329 arg4 = static_cast< byte >(val4);
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj = 0;
12345 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12346 wxColour *arg2 = 0 ;
12347 unsigned long result;
12348 void *argp1 = 0 ;
12349 int res1 = 0 ;
12350 wxColour temp2 ;
12351 PyObject * obj0 = 0 ;
12352 PyObject * obj1 = 0 ;
12353 char * kwnames[] = {
12354 (char *) "self",(char *) "colour", NULL
12355 };
12356
12357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12359 if (!SWIG_IsOK(res1)) {
12360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12361 }
12362 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12363 {
12364 arg2 = &temp2;
12365 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12366 }
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 PyObject *obj;
12382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12383 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12384 return SWIG_Py_Void();
12385 }
12386
12387 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12388 return SWIG_Python_InitShadowInstance(args);
12389 }
12390
12391 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12392 PyObject *resultobj = 0;
12393 byte arg1 = (byte) 0 ;
12394 byte arg2 = (byte) 0 ;
12395 byte arg3 = (byte) 0 ;
12396 wxImage_RGBValue *result = 0 ;
12397 unsigned char val1 ;
12398 int ecode1 = 0 ;
12399 unsigned char val2 ;
12400 int ecode2 = 0 ;
12401 unsigned char val3 ;
12402 int ecode3 = 0 ;
12403 PyObject * obj0 = 0 ;
12404 PyObject * obj1 = 0 ;
12405 PyObject * obj2 = 0 ;
12406 char * kwnames[] = {
12407 (char *) "r",(char *) "g",(char *) "b", NULL
12408 };
12409
12410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12411 if (obj0) {
12412 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12413 if (!SWIG_IsOK(ecode1)) {
12414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12415 }
12416 arg1 = static_cast< byte >(val1);
12417 }
12418 if (obj1) {
12419 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12420 if (!SWIG_IsOK(ecode2)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12422 }
12423 arg2 = static_cast< byte >(val2);
12424 }
12425 if (obj2) {
12426 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12427 if (!SWIG_IsOK(ecode3)) {
12428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12429 }
12430 arg3 = static_cast< byte >(val3);
12431 }
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12435 wxPyEndAllowThreads(__tstate);
12436 if (PyErr_Occurred()) SWIG_fail;
12437 }
12438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12439 return resultobj;
12440 fail:
12441 return NULL;
12442 }
12443
12444
12445 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12446 PyObject *resultobj = 0;
12447 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12448 byte arg2 ;
12449 void *argp1 = 0 ;
12450 int res1 = 0 ;
12451 unsigned char val2 ;
12452 int ecode2 = 0 ;
12453 PyObject *swig_obj[2] ;
12454
12455 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12457 if (!SWIG_IsOK(res1)) {
12458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12459 }
12460 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12461 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12462 if (!SWIG_IsOK(ecode2)) {
12463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12464 }
12465 arg2 = static_cast< byte >(val2);
12466 if (arg1) (arg1)->red = arg2;
12467
12468 resultobj = SWIG_Py_Void();
12469 return resultobj;
12470 fail:
12471 return NULL;
12472 }
12473
12474
12475 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12476 PyObject *resultobj = 0;
12477 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12478 byte result;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 PyObject *swig_obj[1] ;
12482
12483 if (!args) SWIG_fail;
12484 swig_obj[0] = args;
12485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12488 }
12489 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12490 result = (byte) ((arg1)->red);
12491 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12499 PyObject *resultobj = 0;
12500 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12501 byte arg2 ;
12502 void *argp1 = 0 ;
12503 int res1 = 0 ;
12504 unsigned char val2 ;
12505 int ecode2 = 0 ;
12506 PyObject *swig_obj[2] ;
12507
12508 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12510 if (!SWIG_IsOK(res1)) {
12511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12512 }
12513 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12514 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12515 if (!SWIG_IsOK(ecode2)) {
12516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12517 }
12518 arg2 = static_cast< byte >(val2);
12519 if (arg1) (arg1)->green = arg2;
12520
12521 resultobj = SWIG_Py_Void();
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12529 PyObject *resultobj = 0;
12530 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12531 byte result;
12532 void *argp1 = 0 ;
12533 int res1 = 0 ;
12534 PyObject *swig_obj[1] ;
12535
12536 if (!args) SWIG_fail;
12537 swig_obj[0] = args;
12538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12539 if (!SWIG_IsOK(res1)) {
12540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12541 }
12542 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12543 result = (byte) ((arg1)->green);
12544 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12552 PyObject *resultobj = 0;
12553 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12554 byte arg2 ;
12555 void *argp1 = 0 ;
12556 int res1 = 0 ;
12557 unsigned char val2 ;
12558 int ecode2 = 0 ;
12559 PyObject *swig_obj[2] ;
12560
12561 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12563 if (!SWIG_IsOK(res1)) {
12564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12565 }
12566 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12567 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12568 if (!SWIG_IsOK(ecode2)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12570 }
12571 arg2 = static_cast< byte >(val2);
12572 if (arg1) (arg1)->blue = arg2;
12573
12574 resultobj = SWIG_Py_Void();
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12582 PyObject *resultobj = 0;
12583 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12584 byte result;
12585 void *argp1 = 0 ;
12586 int res1 = 0 ;
12587 PyObject *swig_obj[1] ;
12588
12589 if (!args) SWIG_fail;
12590 swig_obj[0] = args;
12591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12592 if (!SWIG_IsOK(res1)) {
12593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12594 }
12595 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12596 result = (byte) ((arg1)->blue);
12597 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12605 PyObject *obj;
12606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12607 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12608 return SWIG_Py_Void();
12609 }
12610
12611 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12612 return SWIG_Python_InitShadowInstance(args);
12613 }
12614
12615 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12616 PyObject *resultobj = 0;
12617 double arg1 = (double) 0.0 ;
12618 double arg2 = (double) 0.0 ;
12619 double arg3 = (double) 0.0 ;
12620 wxImage_HSVValue *result = 0 ;
12621 double val1 ;
12622 int ecode1 = 0 ;
12623 double val2 ;
12624 int ecode2 = 0 ;
12625 double val3 ;
12626 int ecode3 = 0 ;
12627 PyObject * obj0 = 0 ;
12628 PyObject * obj1 = 0 ;
12629 PyObject * obj2 = 0 ;
12630 char * kwnames[] = {
12631 (char *) "h",(char *) "s",(char *) "v", NULL
12632 };
12633
12634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12635 if (obj0) {
12636 ecode1 = SWIG_AsVal_double(obj0, &val1);
12637 if (!SWIG_IsOK(ecode1)) {
12638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12639 }
12640 arg1 = static_cast< double >(val1);
12641 }
12642 if (obj1) {
12643 ecode2 = SWIG_AsVal_double(obj1, &val2);
12644 if (!SWIG_IsOK(ecode2)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12646 }
12647 arg2 = static_cast< double >(val2);
12648 }
12649 if (obj2) {
12650 ecode3 = SWIG_AsVal_double(obj2, &val3);
12651 if (!SWIG_IsOK(ecode3)) {
12652 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12653 }
12654 arg3 = static_cast< double >(val3);
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12659 wxPyEndAllowThreads(__tstate);
12660 if (PyErr_Occurred()) SWIG_fail;
12661 }
12662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12663 return resultobj;
12664 fail:
12665 return NULL;
12666 }
12667
12668
12669 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12670 PyObject *resultobj = 0;
12671 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12672 double arg2 ;
12673 void *argp1 = 0 ;
12674 int res1 = 0 ;
12675 double val2 ;
12676 int ecode2 = 0 ;
12677 PyObject *swig_obj[2] ;
12678
12679 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12681 if (!SWIG_IsOK(res1)) {
12682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12683 }
12684 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12685 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12686 if (!SWIG_IsOK(ecode2)) {
12687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12688 }
12689 arg2 = static_cast< double >(val2);
12690 if (arg1) (arg1)->hue = arg2;
12691
12692 resultobj = SWIG_Py_Void();
12693 return resultobj;
12694 fail:
12695 return NULL;
12696 }
12697
12698
12699 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12700 PyObject *resultobj = 0;
12701 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12702 double result;
12703 void *argp1 = 0 ;
12704 int res1 = 0 ;
12705 PyObject *swig_obj[1] ;
12706
12707 if (!args) SWIG_fail;
12708 swig_obj[0] = args;
12709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12710 if (!SWIG_IsOK(res1)) {
12711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12712 }
12713 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12714 result = (double) ((arg1)->hue);
12715 resultobj = SWIG_From_double(static_cast< double >(result));
12716 return resultobj;
12717 fail:
12718 return NULL;
12719 }
12720
12721
12722 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12723 PyObject *resultobj = 0;
12724 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12725 double arg2 ;
12726 void *argp1 = 0 ;
12727 int res1 = 0 ;
12728 double val2 ;
12729 int ecode2 = 0 ;
12730 PyObject *swig_obj[2] ;
12731
12732 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12736 }
12737 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12738 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12739 if (!SWIG_IsOK(ecode2)) {
12740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12741 }
12742 arg2 = static_cast< double >(val2);
12743 if (arg1) (arg1)->saturation = arg2;
12744
12745 resultobj = SWIG_Py_Void();
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12753 PyObject *resultobj = 0;
12754 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12755 double result;
12756 void *argp1 = 0 ;
12757 int res1 = 0 ;
12758 PyObject *swig_obj[1] ;
12759
12760 if (!args) SWIG_fail;
12761 swig_obj[0] = args;
12762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12763 if (!SWIG_IsOK(res1)) {
12764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12765 }
12766 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12767 result = (double) ((arg1)->saturation);
12768 resultobj = SWIG_From_double(static_cast< double >(result));
12769 return resultobj;
12770 fail:
12771 return NULL;
12772 }
12773
12774
12775 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12776 PyObject *resultobj = 0;
12777 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12778 double arg2 ;
12779 void *argp1 = 0 ;
12780 int res1 = 0 ;
12781 double val2 ;
12782 int ecode2 = 0 ;
12783 PyObject *swig_obj[2] ;
12784
12785 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12787 if (!SWIG_IsOK(res1)) {
12788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12789 }
12790 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12791 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12792 if (!SWIG_IsOK(ecode2)) {
12793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12794 }
12795 arg2 = static_cast< double >(val2);
12796 if (arg1) (arg1)->value = arg2;
12797
12798 resultobj = SWIG_Py_Void();
12799 return resultobj;
12800 fail:
12801 return NULL;
12802 }
12803
12804
12805 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12806 PyObject *resultobj = 0;
12807 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12808 double result;
12809 void *argp1 = 0 ;
12810 int res1 = 0 ;
12811 PyObject *swig_obj[1] ;
12812
12813 if (!args) SWIG_fail;
12814 swig_obj[0] = args;
12815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12816 if (!SWIG_IsOK(res1)) {
12817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12818 }
12819 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12820 result = (double) ((arg1)->value);
12821 resultobj = SWIG_From_double(static_cast< double >(result));
12822 return resultobj;
12823 fail:
12824 return NULL;
12825 }
12826
12827
12828 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12829 PyObject *obj;
12830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12831 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12832 return SWIG_Py_Void();
12833 }
12834
12835 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12836 return SWIG_Python_InitShadowInstance(args);
12837 }
12838
12839 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12840 PyObject *resultobj = 0;
12841 wxString *arg1 = 0 ;
12842 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12843 int arg3 = (int) -1 ;
12844 wxImage *result = 0 ;
12845 bool temp1 = false ;
12846 long val2 ;
12847 int ecode2 = 0 ;
12848 int val3 ;
12849 int ecode3 = 0 ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 PyObject * obj2 = 0 ;
12853 char * kwnames[] = {
12854 (char *) "name",(char *) "type",(char *) "index", NULL
12855 };
12856
12857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12858 {
12859 arg1 = wxString_in_helper(obj0);
12860 if (arg1 == NULL) SWIG_fail;
12861 temp1 = true;
12862 }
12863 if (obj1) {
12864 ecode2 = SWIG_AsVal_long(obj1, &val2);
12865 if (!SWIG_IsOK(ecode2)) {
12866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12867 }
12868 arg2 = static_cast< long >(val2);
12869 }
12870 if (obj2) {
12871 ecode3 = SWIG_AsVal_int(obj2, &val3);
12872 if (!SWIG_IsOK(ecode3)) {
12873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12874 }
12875 arg3 = static_cast< int >(val3);
12876 }
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12880 wxPyEndAllowThreads(__tstate);
12881 if (PyErr_Occurred()) SWIG_fail;
12882 }
12883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12884 {
12885 if (temp1)
12886 delete arg1;
12887 }
12888 return resultobj;
12889 fail:
12890 {
12891 if (temp1)
12892 delete arg1;
12893 }
12894 return NULL;
12895 }
12896
12897
12898 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12899 PyObject *resultobj = 0;
12900 wxImage *arg1 = (wxImage *) 0 ;
12901 void *argp1 = 0 ;
12902 int res1 = 0 ;
12903 PyObject *swig_obj[1] ;
12904
12905 if (!args) SWIG_fail;
12906 swig_obj[0] = args;
12907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12908 if (!SWIG_IsOK(res1)) {
12909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12910 }
12911 arg1 = reinterpret_cast< wxImage * >(argp1);
12912 {
12913 PyThreadState* __tstate = wxPyBeginAllowThreads();
12914 delete arg1;
12915
12916 wxPyEndAllowThreads(__tstate);
12917 if (PyErr_Occurred()) SWIG_fail;
12918 }
12919 resultobj = SWIG_Py_Void();
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12927 PyObject *resultobj = 0;
12928 wxString *arg1 = 0 ;
12929 wxString *arg2 = 0 ;
12930 int arg3 = (int) -1 ;
12931 wxImage *result = 0 ;
12932 bool temp1 = false ;
12933 bool temp2 = false ;
12934 int val3 ;
12935 int ecode3 = 0 ;
12936 PyObject * obj0 = 0 ;
12937 PyObject * obj1 = 0 ;
12938 PyObject * obj2 = 0 ;
12939 char * kwnames[] = {
12940 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12941 };
12942
12943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12944 {
12945 arg1 = wxString_in_helper(obj0);
12946 if (arg1 == NULL) SWIG_fail;
12947 temp1 = true;
12948 }
12949 {
12950 arg2 = wxString_in_helper(obj1);
12951 if (arg2 == NULL) SWIG_fail;
12952 temp2 = true;
12953 }
12954 if (obj2) {
12955 ecode3 = SWIG_AsVal_int(obj2, &val3);
12956 if (!SWIG_IsOK(ecode3)) {
12957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12958 }
12959 arg3 = static_cast< int >(val3);
12960 }
12961 {
12962 PyThreadState* __tstate = wxPyBeginAllowThreads();
12963 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12968 {
12969 if (temp1)
12970 delete arg1;
12971 }
12972 {
12973 if (temp2)
12974 delete arg2;
12975 }
12976 return resultobj;
12977 fail:
12978 {
12979 if (temp1)
12980 delete arg1;
12981 }
12982 {
12983 if (temp2)
12984 delete arg2;
12985 }
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12991 PyObject *resultobj = 0;
12992 wxInputStream *arg1 = 0 ;
12993 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12994 int arg3 = (int) -1 ;
12995 wxImage *result = 0 ;
12996 wxPyInputStream *temp1 ;
12997 bool created1 ;
12998 long val2 ;
12999 int ecode2 = 0 ;
13000 int val3 ;
13001 int ecode3 = 0 ;
13002 PyObject * obj0 = 0 ;
13003 PyObject * obj1 = 0 ;
13004 PyObject * obj2 = 0 ;
13005 char * kwnames[] = {
13006 (char *) "stream",(char *) "type",(char *) "index", NULL
13007 };
13008
13009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13010 {
13011 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13012 arg1 = temp1->m_wxis;
13013 created1 = false;
13014 } else {
13015 PyErr_Clear(); // clear the failure of the wxPyConvert above
13016 arg1 = wxPyCBInputStream_create(obj0, false);
13017 if (arg1 == NULL) {
13018 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13019 SWIG_fail;
13020 }
13021 created1 = true;
13022 }
13023 }
13024 if (obj1) {
13025 ecode2 = SWIG_AsVal_long(obj1, &val2);
13026 if (!SWIG_IsOK(ecode2)) {
13027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13028 }
13029 arg2 = static_cast< long >(val2);
13030 }
13031 if (obj2) {
13032 ecode3 = SWIG_AsVal_int(obj2, &val3);
13033 if (!SWIG_IsOK(ecode3)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13035 }
13036 arg3 = static_cast< int >(val3);
13037 }
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13045 {
13046 if (created1) delete arg1;
13047 }
13048 return resultobj;
13049 fail:
13050 {
13051 if (created1) delete arg1;
13052 }
13053 return NULL;
13054 }
13055
13056
13057 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj = 0;
13059 wxInputStream *arg1 = 0 ;
13060 wxString *arg2 = 0 ;
13061 int arg3 = (int) -1 ;
13062 wxImage *result = 0 ;
13063 wxPyInputStream *temp1 ;
13064 bool created1 ;
13065 bool temp2 = false ;
13066 int val3 ;
13067 int ecode3 = 0 ;
13068 PyObject * obj0 = 0 ;
13069 PyObject * obj1 = 0 ;
13070 PyObject * obj2 = 0 ;
13071 char * kwnames[] = {
13072 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13073 };
13074
13075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13076 {
13077 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13078 arg1 = temp1->m_wxis;
13079 created1 = false;
13080 } else {
13081 PyErr_Clear(); // clear the failure of the wxPyConvert above
13082 arg1 = wxPyCBInputStream_create(obj0, false);
13083 if (arg1 == NULL) {
13084 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13085 SWIG_fail;
13086 }
13087 created1 = true;
13088 }
13089 }
13090 {
13091 arg2 = wxString_in_helper(obj1);
13092 if (arg2 == NULL) SWIG_fail;
13093 temp2 = true;
13094 }
13095 if (obj2) {
13096 ecode3 = SWIG_AsVal_int(obj2, &val3);
13097 if (!SWIG_IsOK(ecode3)) {
13098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13099 }
13100 arg3 = static_cast< int >(val3);
13101 }
13102 {
13103 PyThreadState* __tstate = wxPyBeginAllowThreads();
13104 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13105 wxPyEndAllowThreads(__tstate);
13106 if (PyErr_Occurred()) SWIG_fail;
13107 }
13108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13109 {
13110 if (created1) delete arg1;
13111 }
13112 {
13113 if (temp2)
13114 delete arg2;
13115 }
13116 return resultobj;
13117 fail:
13118 {
13119 if (created1) delete arg1;
13120 }
13121 {
13122 if (temp2)
13123 delete arg2;
13124 }
13125 return NULL;
13126 }
13127
13128
13129 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13130 PyObject *resultobj = 0;
13131 int arg1 = (int) 0 ;
13132 int arg2 = (int) 0 ;
13133 bool arg3 = (bool) true ;
13134 wxImage *result = 0 ;
13135 int val1 ;
13136 int ecode1 = 0 ;
13137 int val2 ;
13138 int ecode2 = 0 ;
13139 bool val3 ;
13140 int ecode3 = 0 ;
13141 PyObject * obj0 = 0 ;
13142 PyObject * obj1 = 0 ;
13143 PyObject * obj2 = 0 ;
13144 char * kwnames[] = {
13145 (char *) "width",(char *) "height",(char *) "clear", NULL
13146 };
13147
13148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13149 if (obj0) {
13150 ecode1 = SWIG_AsVal_int(obj0, &val1);
13151 if (!SWIG_IsOK(ecode1)) {
13152 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13153 }
13154 arg1 = static_cast< int >(val1);
13155 }
13156 if (obj1) {
13157 ecode2 = SWIG_AsVal_int(obj1, &val2);
13158 if (!SWIG_IsOK(ecode2)) {
13159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13160 }
13161 arg2 = static_cast< int >(val2);
13162 }
13163 if (obj2) {
13164 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13165 if (!SWIG_IsOK(ecode3)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13167 }
13168 arg3 = static_cast< bool >(val3);
13169 }
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13173 wxPyEndAllowThreads(__tstate);
13174 if (PyErr_Occurred()) SWIG_fail;
13175 }
13176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13177 return resultobj;
13178 fail:
13179 return NULL;
13180 }
13181
13182
13183 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13184 PyObject *resultobj = 0;
13185 wxBitmap *arg1 = 0 ;
13186 wxImage *result = 0 ;
13187 void *argp1 = 0 ;
13188 int res1 = 0 ;
13189 PyObject * obj0 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "bitmap", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13195 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13196 if (!SWIG_IsOK(res1)) {
13197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13198 }
13199 if (!argp1) {
13200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13201 }
13202 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13203 {
13204 if (!wxPyCheckForApp()) SWIG_fail;
13205 PyThreadState* __tstate = wxPyBeginAllowThreads();
13206 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
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 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj = 0;
13219 int arg1 ;
13220 int arg2 ;
13221 buffer arg3 ;
13222 int arg4 ;
13223 wxImage *result = 0 ;
13224 int val1 ;
13225 int ecode1 = 0 ;
13226 int val2 ;
13227 int ecode2 = 0 ;
13228 PyObject * obj0 = 0 ;
13229 PyObject * obj1 = 0 ;
13230 PyObject * obj2 = 0 ;
13231 char * kwnames[] = {
13232 (char *) "width",(char *) "height",(char *) "data", NULL
13233 };
13234
13235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13236 ecode1 = SWIG_AsVal_int(obj0, &val1);
13237 if (!SWIG_IsOK(ecode1)) {
13238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13239 }
13240 arg1 = static_cast< int >(val1);
13241 ecode2 = SWIG_AsVal_int(obj1, &val2);
13242 if (!SWIG_IsOK(ecode2)) {
13243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13244 }
13245 arg2 = static_cast< int >(val2);
13246 {
13247 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13248 }
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj = 0;
13264 int arg1 ;
13265 int arg2 ;
13266 buffer arg3 ;
13267 int arg4 ;
13268 buffer arg5 ;
13269 int arg6 ;
13270 wxImage *result = 0 ;
13271 int val1 ;
13272 int ecode1 = 0 ;
13273 int val2 ;
13274 int ecode2 = 0 ;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 PyObject * obj2 = 0 ;
13278 PyObject * obj3 = 0 ;
13279 char * kwnames[] = {
13280 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13281 };
13282
13283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13284 ecode1 = SWIG_AsVal_int(obj0, &val1);
13285 if (!SWIG_IsOK(ecode1)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13287 }
13288 arg1 = static_cast< int >(val1);
13289 ecode2 = SWIG_AsVal_int(obj1, &val2);
13290 if (!SWIG_IsOK(ecode2)) {
13291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13292 }
13293 arg2 = static_cast< int >(val2);
13294 {
13295 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13296 }
13297 {
13298 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13299 }
13300 {
13301 PyThreadState* __tstate = wxPyBeginAllowThreads();
13302 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = 0;
13315 wxImage *arg1 = (wxImage *) 0 ;
13316 int arg2 ;
13317 int arg3 ;
13318 bool arg4 = (bool) true ;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 int val2 ;
13322 int ecode2 = 0 ;
13323 int val3 ;
13324 int ecode3 = 0 ;
13325 bool val4 ;
13326 int ecode4 = 0 ;
13327 PyObject * obj0 = 0 ;
13328 PyObject * obj1 = 0 ;
13329 PyObject * obj2 = 0 ;
13330 PyObject * obj3 = 0 ;
13331 char * kwnames[] = {
13332 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13333 };
13334
13335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13337 if (!SWIG_IsOK(res1)) {
13338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13339 }
13340 arg1 = reinterpret_cast< wxImage * >(argp1);
13341 ecode2 = SWIG_AsVal_int(obj1, &val2);
13342 if (!SWIG_IsOK(ecode2)) {
13343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13344 }
13345 arg2 = static_cast< int >(val2);
13346 ecode3 = SWIG_AsVal_int(obj2, &val3);
13347 if (!SWIG_IsOK(ecode3)) {
13348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13349 }
13350 arg3 = static_cast< int >(val3);
13351 if (obj3) {
13352 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13353 if (!SWIG_IsOK(ecode4)) {
13354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13355 }
13356 arg4 = static_cast< bool >(val4);
13357 }
13358 {
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 (arg1)->Create(arg2,arg3,arg4);
13361 wxPyEndAllowThreads(__tstate);
13362 if (PyErr_Occurred()) SWIG_fail;
13363 }
13364 resultobj = SWIG_Py_Void();
13365 return resultobj;
13366 fail:
13367 return NULL;
13368 }
13369
13370
13371 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13372 PyObject *resultobj = 0;
13373 wxImage *arg1 = (wxImage *) 0 ;
13374 void *argp1 = 0 ;
13375 int res1 = 0 ;
13376 PyObject *swig_obj[1] ;
13377
13378 if (!args) SWIG_fail;
13379 swig_obj[0] = args;
13380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13381 if (!SWIG_IsOK(res1)) {
13382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13383 }
13384 arg1 = reinterpret_cast< wxImage * >(argp1);
13385 {
13386 PyThreadState* __tstate = wxPyBeginAllowThreads();
13387 (arg1)->Destroy();
13388 wxPyEndAllowThreads(__tstate);
13389 if (PyErr_Occurred()) SWIG_fail;
13390 }
13391 resultobj = SWIG_Py_Void();
13392 return resultobj;
13393 fail:
13394 return NULL;
13395 }
13396
13397
13398 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13399 PyObject *resultobj = 0;
13400 wxImage *arg1 = (wxImage *) 0 ;
13401 int arg2 ;
13402 int arg3 ;
13403 SwigValueWrapper<wxImage > result;
13404 void *argp1 = 0 ;
13405 int res1 = 0 ;
13406 int val2 ;
13407 int ecode2 = 0 ;
13408 int val3 ;
13409 int ecode3 = 0 ;
13410 PyObject * obj0 = 0 ;
13411 PyObject * obj1 = 0 ;
13412 PyObject * obj2 = 0 ;
13413 char * kwnames[] = {
13414 (char *) "self",(char *) "width",(char *) "height", NULL
13415 };
13416
13417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13419 if (!SWIG_IsOK(res1)) {
13420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13421 }
13422 arg1 = reinterpret_cast< wxImage * >(argp1);
13423 ecode2 = SWIG_AsVal_int(obj1, &val2);
13424 if (!SWIG_IsOK(ecode2)) {
13425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13426 }
13427 arg2 = static_cast< int >(val2);
13428 ecode3 = SWIG_AsVal_int(obj2, &val3);
13429 if (!SWIG_IsOK(ecode3)) {
13430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13431 }
13432 arg3 = static_cast< int >(val3);
13433 {
13434 PyThreadState* __tstate = wxPyBeginAllowThreads();
13435 result = (arg1)->Scale(arg2,arg3);
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13440 return resultobj;
13441 fail:
13442 return NULL;
13443 }
13444
13445
13446 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13447 PyObject *resultobj = 0;
13448 wxImage *arg1 = (wxImage *) 0 ;
13449 int arg2 ;
13450 int arg3 ;
13451 SwigValueWrapper<wxImage > result;
13452 void *argp1 = 0 ;
13453 int res1 = 0 ;
13454 int val2 ;
13455 int ecode2 = 0 ;
13456 int val3 ;
13457 int ecode3 = 0 ;
13458 PyObject * obj0 = 0 ;
13459 PyObject * obj1 = 0 ;
13460 PyObject * obj2 = 0 ;
13461 char * kwnames[] = {
13462 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13463 };
13464
13465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13467 if (!SWIG_IsOK(res1)) {
13468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13469 }
13470 arg1 = reinterpret_cast< wxImage * >(argp1);
13471 ecode2 = SWIG_AsVal_int(obj1, &val2);
13472 if (!SWIG_IsOK(ecode2)) {
13473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13474 }
13475 arg2 = static_cast< int >(val2);
13476 ecode3 = SWIG_AsVal_int(obj2, &val3);
13477 if (!SWIG_IsOK(ecode3)) {
13478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13479 }
13480 arg3 = static_cast< int >(val3);
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13488 return resultobj;
13489 fail:
13490 return NULL;
13491 }
13492
13493
13494 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13495 PyObject *resultobj = 0;
13496 wxImage *arg1 = (wxImage *) 0 ;
13497 int arg2 ;
13498 int arg3 ;
13499 wxImage *result = 0 ;
13500 void *argp1 = 0 ;
13501 int res1 = 0 ;
13502 int val2 ;
13503 int ecode2 = 0 ;
13504 int val3 ;
13505 int ecode3 = 0 ;
13506 PyObject * obj0 = 0 ;
13507 PyObject * obj1 = 0 ;
13508 PyObject * obj2 = 0 ;
13509 char * kwnames[] = {
13510 (char *) "self",(char *) "width",(char *) "height", NULL
13511 };
13512
13513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13515 if (!SWIG_IsOK(res1)) {
13516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13517 }
13518 arg1 = reinterpret_cast< wxImage * >(argp1);
13519 ecode2 = SWIG_AsVal_int(obj1, &val2);
13520 if (!SWIG_IsOK(ecode2)) {
13521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13522 }
13523 arg2 = static_cast< int >(val2);
13524 ecode3 = SWIG_AsVal_int(obj2, &val3);
13525 if (!SWIG_IsOK(ecode3)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13527 }
13528 arg3 = static_cast< int >(val3);
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 {
13532 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13533 result = (wxImage *) &_result_ref;
13534 }
13535 wxPyEndAllowThreads(__tstate);
13536 if (PyErr_Occurred()) SWIG_fail;
13537 }
13538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = 0;
13547 wxImage *arg1 = (wxImage *) 0 ;
13548 wxSize *arg2 = 0 ;
13549 wxPoint *arg3 = 0 ;
13550 int arg4 = (int) -1 ;
13551 int arg5 = (int) -1 ;
13552 int arg6 = (int) -1 ;
13553 wxImage *result = 0 ;
13554 void *argp1 = 0 ;
13555 int res1 = 0 ;
13556 wxSize temp2 ;
13557 wxPoint temp3 ;
13558 int val4 ;
13559 int ecode4 = 0 ;
13560 int val5 ;
13561 int ecode5 = 0 ;
13562 int val6 ;
13563 int ecode6 = 0 ;
13564 PyObject * obj0 = 0 ;
13565 PyObject * obj1 = 0 ;
13566 PyObject * obj2 = 0 ;
13567 PyObject * obj3 = 0 ;
13568 PyObject * obj4 = 0 ;
13569 PyObject * obj5 = 0 ;
13570 char * kwnames[] = {
13571 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13572 };
13573
13574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13576 if (!SWIG_IsOK(res1)) {
13577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13578 }
13579 arg1 = reinterpret_cast< wxImage * >(argp1);
13580 {
13581 arg2 = &temp2;
13582 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13583 }
13584 {
13585 arg3 = &temp3;
13586 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13587 }
13588 if (obj3) {
13589 ecode4 = SWIG_AsVal_int(obj3, &val4);
13590 if (!SWIG_IsOK(ecode4)) {
13591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13592 }
13593 arg4 = static_cast< int >(val4);
13594 }
13595 if (obj4) {
13596 ecode5 = SWIG_AsVal_int(obj4, &val5);
13597 if (!SWIG_IsOK(ecode5)) {
13598 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13599 }
13600 arg5 = static_cast< int >(val5);
13601 }
13602 if (obj5) {
13603 ecode6 = SWIG_AsVal_int(obj5, &val6);
13604 if (!SWIG_IsOK(ecode6)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13606 }
13607 arg6 = static_cast< int >(val6);
13608 }
13609 {
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 {
13612 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13613 result = (wxImage *) &_result_ref;
13614 }
13615 wxPyEndAllowThreads(__tstate);
13616 if (PyErr_Occurred()) SWIG_fail;
13617 }
13618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13619 return resultobj;
13620 fail:
13621 return NULL;
13622 }
13623
13624
13625 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13626 PyObject *resultobj = 0;
13627 wxImage *arg1 = (wxImage *) 0 ;
13628 int arg2 ;
13629 int arg3 ;
13630 byte arg4 ;
13631 byte arg5 ;
13632 byte arg6 ;
13633 void *argp1 = 0 ;
13634 int res1 = 0 ;
13635 int val2 ;
13636 int ecode2 = 0 ;
13637 int val3 ;
13638 int ecode3 = 0 ;
13639 unsigned char val4 ;
13640 int ecode4 = 0 ;
13641 unsigned char val5 ;
13642 int ecode5 = 0 ;
13643 unsigned char val6 ;
13644 int ecode6 = 0 ;
13645 PyObject * obj0 = 0 ;
13646 PyObject * obj1 = 0 ;
13647 PyObject * obj2 = 0 ;
13648 PyObject * obj3 = 0 ;
13649 PyObject * obj4 = 0 ;
13650 PyObject * obj5 = 0 ;
13651 char * kwnames[] = {
13652 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13653 };
13654
13655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13657 if (!SWIG_IsOK(res1)) {
13658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13659 }
13660 arg1 = reinterpret_cast< wxImage * >(argp1);
13661 ecode2 = SWIG_AsVal_int(obj1, &val2);
13662 if (!SWIG_IsOK(ecode2)) {
13663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13664 }
13665 arg2 = static_cast< int >(val2);
13666 ecode3 = SWIG_AsVal_int(obj2, &val3);
13667 if (!SWIG_IsOK(ecode3)) {
13668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13669 }
13670 arg3 = static_cast< int >(val3);
13671 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13672 if (!SWIG_IsOK(ecode4)) {
13673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13674 }
13675 arg4 = static_cast< byte >(val4);
13676 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13677 if (!SWIG_IsOK(ecode5)) {
13678 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13679 }
13680 arg5 = static_cast< byte >(val5);
13681 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13682 if (!SWIG_IsOK(ecode6)) {
13683 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13684 }
13685 arg6 = static_cast< byte >(val6);
13686 {
13687 PyThreadState* __tstate = wxPyBeginAllowThreads();
13688 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13689 wxPyEndAllowThreads(__tstate);
13690 if (PyErr_Occurred()) SWIG_fail;
13691 }
13692 resultobj = SWIG_Py_Void();
13693 return resultobj;
13694 fail:
13695 return NULL;
13696 }
13697
13698
13699 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13700 PyObject *resultobj = 0;
13701 wxImage *arg1 = (wxImage *) 0 ;
13702 wxRect *arg2 = 0 ;
13703 byte arg3 ;
13704 byte arg4 ;
13705 byte arg5 ;
13706 void *argp1 = 0 ;
13707 int res1 = 0 ;
13708 wxRect temp2 ;
13709 unsigned char val3 ;
13710 int ecode3 = 0 ;
13711 unsigned char val4 ;
13712 int ecode4 = 0 ;
13713 unsigned char val5 ;
13714 int ecode5 = 0 ;
13715 PyObject * obj0 = 0 ;
13716 PyObject * obj1 = 0 ;
13717 PyObject * obj2 = 0 ;
13718 PyObject * obj3 = 0 ;
13719 PyObject * obj4 = 0 ;
13720 char * kwnames[] = {
13721 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13722 };
13723
13724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13726 if (!SWIG_IsOK(res1)) {
13727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13728 }
13729 arg1 = reinterpret_cast< wxImage * >(argp1);
13730 {
13731 arg2 = &temp2;
13732 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13733 }
13734 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13735 if (!SWIG_IsOK(ecode3)) {
13736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13737 }
13738 arg3 = static_cast< byte >(val3);
13739 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13740 if (!SWIG_IsOK(ecode4)) {
13741 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13742 }
13743 arg4 = static_cast< byte >(val4);
13744 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13745 if (!SWIG_IsOK(ecode5)) {
13746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13747 }
13748 arg5 = static_cast< byte >(val5);
13749 {
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_Py_Void();
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj = 0;
13764 wxImage *arg1 = (wxImage *) 0 ;
13765 int arg2 ;
13766 int arg3 ;
13767 byte result;
13768 void *argp1 = 0 ;
13769 int res1 = 0 ;
13770 int val2 ;
13771 int ecode2 = 0 ;
13772 int val3 ;
13773 int ecode3 = 0 ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 char * kwnames[] = {
13778 (char *) "self",(char *) "x",(char *) "y", NULL
13779 };
13780
13781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13783 if (!SWIG_IsOK(res1)) {
13784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13785 }
13786 arg1 = reinterpret_cast< wxImage * >(argp1);
13787 ecode2 = SWIG_AsVal_int(obj1, &val2);
13788 if (!SWIG_IsOK(ecode2)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13790 }
13791 arg2 = static_cast< int >(val2);
13792 ecode3 = SWIG_AsVal_int(obj2, &val3);
13793 if (!SWIG_IsOK(ecode3)) {
13794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13795 }
13796 arg3 = static_cast< int >(val3);
13797 {
13798 PyThreadState* __tstate = wxPyBeginAllowThreads();
13799 result = (byte)(arg1)->GetRed(arg2,arg3);
13800 wxPyEndAllowThreads(__tstate);
13801 if (PyErr_Occurred()) SWIG_fail;
13802 }
13803 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13804 return resultobj;
13805 fail:
13806 return NULL;
13807 }
13808
13809
13810 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13811 PyObject *resultobj = 0;
13812 wxImage *arg1 = (wxImage *) 0 ;
13813 int arg2 ;
13814 int arg3 ;
13815 byte result;
13816 void *argp1 = 0 ;
13817 int res1 = 0 ;
13818 int val2 ;
13819 int ecode2 = 0 ;
13820 int val3 ;
13821 int ecode3 = 0 ;
13822 PyObject * obj0 = 0 ;
13823 PyObject * obj1 = 0 ;
13824 PyObject * obj2 = 0 ;
13825 char * kwnames[] = {
13826 (char *) "self",(char *) "x",(char *) "y", NULL
13827 };
13828
13829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13831 if (!SWIG_IsOK(res1)) {
13832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13833 }
13834 arg1 = reinterpret_cast< wxImage * >(argp1);
13835 ecode2 = SWIG_AsVal_int(obj1, &val2);
13836 if (!SWIG_IsOK(ecode2)) {
13837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13838 }
13839 arg2 = static_cast< int >(val2);
13840 ecode3 = SWIG_AsVal_int(obj2, &val3);
13841 if (!SWIG_IsOK(ecode3)) {
13842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13843 }
13844 arg3 = static_cast< int >(val3);
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 result = (byte)(arg1)->GetGreen(arg2,arg3);
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj = 0;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 int arg2 ;
13862 int arg3 ;
13863 byte result;
13864 void *argp1 = 0 ;
13865 int res1 = 0 ;
13866 int val2 ;
13867 int ecode2 = 0 ;
13868 int val3 ;
13869 int ecode3 = 0 ;
13870 PyObject * obj0 = 0 ;
13871 PyObject * obj1 = 0 ;
13872 PyObject * obj2 = 0 ;
13873 char * kwnames[] = {
13874 (char *) "self",(char *) "x",(char *) "y", NULL
13875 };
13876
13877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13879 if (!SWIG_IsOK(res1)) {
13880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13881 }
13882 arg1 = reinterpret_cast< wxImage * >(argp1);
13883 ecode2 = SWIG_AsVal_int(obj1, &val2);
13884 if (!SWIG_IsOK(ecode2)) {
13885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13886 }
13887 arg2 = static_cast< int >(val2);
13888 ecode3 = SWIG_AsVal_int(obj2, &val3);
13889 if (!SWIG_IsOK(ecode3)) {
13890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13891 }
13892 arg3 = static_cast< int >(val3);
13893 {
13894 PyThreadState* __tstate = wxPyBeginAllowThreads();
13895 result = (byte)(arg1)->GetBlue(arg2,arg3);
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13900 return resultobj;
13901 fail:
13902 return NULL;
13903 }
13904
13905
13906 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = 0;
13908 wxImage *arg1 = (wxImage *) 0 ;
13909 int arg2 ;
13910 int arg3 ;
13911 byte arg4 ;
13912 void *argp1 = 0 ;
13913 int res1 = 0 ;
13914 int val2 ;
13915 int ecode2 = 0 ;
13916 int val3 ;
13917 int ecode3 = 0 ;
13918 unsigned char val4 ;
13919 int ecode4 = 0 ;
13920 PyObject * obj0 = 0 ;
13921 PyObject * obj1 = 0 ;
13922 PyObject * obj2 = 0 ;
13923 PyObject * obj3 = 0 ;
13924 char * kwnames[] = {
13925 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13926 };
13927
13928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13930 if (!SWIG_IsOK(res1)) {
13931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13932 }
13933 arg1 = reinterpret_cast< wxImage * >(argp1);
13934 ecode2 = SWIG_AsVal_int(obj1, &val2);
13935 if (!SWIG_IsOK(ecode2)) {
13936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13937 }
13938 arg2 = static_cast< int >(val2);
13939 ecode3 = SWIG_AsVal_int(obj2, &val3);
13940 if (!SWIG_IsOK(ecode3)) {
13941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13942 }
13943 arg3 = static_cast< int >(val3);
13944 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13945 if (!SWIG_IsOK(ecode4)) {
13946 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13947 }
13948 arg4 = static_cast< byte >(val4);
13949 {
13950 PyThreadState* __tstate = wxPyBeginAllowThreads();
13951 (arg1)->SetAlpha(arg2,arg3,arg4);
13952 wxPyEndAllowThreads(__tstate);
13953 if (PyErr_Occurred()) SWIG_fail;
13954 }
13955 resultobj = SWIG_Py_Void();
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj = 0;
13964 wxImage *arg1 = (wxImage *) 0 ;
13965 int arg2 ;
13966 int arg3 ;
13967 byte result;
13968 void *argp1 = 0 ;
13969 int res1 = 0 ;
13970 int val2 ;
13971 int ecode2 = 0 ;
13972 int val3 ;
13973 int ecode3 = 0 ;
13974 PyObject * obj0 = 0 ;
13975 PyObject * obj1 = 0 ;
13976 PyObject * obj2 = 0 ;
13977 char * kwnames[] = {
13978 (char *) "self",(char *) "x",(char *) "y", NULL
13979 };
13980
13981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13983 if (!SWIG_IsOK(res1)) {
13984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13985 }
13986 arg1 = reinterpret_cast< wxImage * >(argp1);
13987 ecode2 = SWIG_AsVal_int(obj1, &val2);
13988 if (!SWIG_IsOK(ecode2)) {
13989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13990 }
13991 arg2 = static_cast< int >(val2);
13992 ecode3 = SWIG_AsVal_int(obj2, &val3);
13993 if (!SWIG_IsOK(ecode3)) {
13994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13995 }
13996 arg3 = static_cast< int >(val3);
13997 {
13998 PyThreadState* __tstate = wxPyBeginAllowThreads();
13999 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14004 return resultobj;
14005 fail:
14006 return NULL;
14007 }
14008
14009
14010 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14011 PyObject *resultobj = 0;
14012 wxImage *arg1 = (wxImage *) 0 ;
14013 bool result;
14014 void *argp1 = 0 ;
14015 int res1 = 0 ;
14016 PyObject *swig_obj[1] ;
14017
14018 if (!args) SWIG_fail;
14019 swig_obj[0] = args;
14020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14021 if (!SWIG_IsOK(res1)) {
14022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14023 }
14024 arg1 = reinterpret_cast< wxImage * >(argp1);
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 result = (bool)(arg1)->HasAlpha();
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 {
14032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14033 }
14034 return resultobj;
14035 fail:
14036 return NULL;
14037 }
14038
14039
14040 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14041 PyObject *resultobj = 0;
14042 wxImage *arg1 = (wxImage *) 0 ;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 PyObject *swig_obj[1] ;
14046
14047 if (!args) SWIG_fail;
14048 swig_obj[0] = args;
14049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14050 if (!SWIG_IsOK(res1)) {
14051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14052 }
14053 arg1 = reinterpret_cast< wxImage * >(argp1);
14054 {
14055 PyThreadState* __tstate = wxPyBeginAllowThreads();
14056 (arg1)->InitAlpha();
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 resultobj = SWIG_Py_Void();
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj = 0;
14069 wxImage *arg1 = (wxImage *) 0 ;
14070 int arg2 ;
14071 int arg3 ;
14072 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14073 bool result;
14074 void *argp1 = 0 ;
14075 int res1 = 0 ;
14076 int val2 ;
14077 int ecode2 = 0 ;
14078 int val3 ;
14079 int ecode3 = 0 ;
14080 unsigned char val4 ;
14081 int ecode4 = 0 ;
14082 PyObject * obj0 = 0 ;
14083 PyObject * obj1 = 0 ;
14084 PyObject * obj2 = 0 ;
14085 PyObject * obj3 = 0 ;
14086 char * kwnames[] = {
14087 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14088 };
14089
14090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14092 if (!SWIG_IsOK(res1)) {
14093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14094 }
14095 arg1 = reinterpret_cast< wxImage * >(argp1);
14096 ecode2 = SWIG_AsVal_int(obj1, &val2);
14097 if (!SWIG_IsOK(ecode2)) {
14098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14099 }
14100 arg2 = static_cast< int >(val2);
14101 ecode3 = SWIG_AsVal_int(obj2, &val3);
14102 if (!SWIG_IsOK(ecode3)) {
14103 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14104 }
14105 arg3 = static_cast< int >(val3);
14106 if (obj3) {
14107 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14108 if (!SWIG_IsOK(ecode4)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14110 }
14111 arg4 = static_cast< byte >(val4);
14112 }
14113 {
14114 PyThreadState* __tstate = wxPyBeginAllowThreads();
14115 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14116 wxPyEndAllowThreads(__tstate);
14117 if (PyErr_Occurred()) SWIG_fail;
14118 }
14119 {
14120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14121 }
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14129 PyObject *resultobj = 0;
14130 wxImage *arg1 = (wxImage *) 0 ;
14131 byte *arg2 = (byte *) 0 ;
14132 byte *arg3 = (byte *) 0 ;
14133 byte *arg4 = (byte *) 0 ;
14134 byte arg5 = (byte) 0 ;
14135 byte arg6 = (byte) 0 ;
14136 byte arg7 = (byte) 0 ;
14137 bool result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 byte temp2 ;
14141 int res2 = SWIG_TMPOBJ ;
14142 byte temp3 ;
14143 int res3 = SWIG_TMPOBJ ;
14144 byte temp4 ;
14145 int res4 = SWIG_TMPOBJ ;
14146 unsigned char val5 ;
14147 int ecode5 = 0 ;
14148 unsigned char val6 ;
14149 int ecode6 = 0 ;
14150 unsigned char val7 ;
14151 int ecode7 = 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 PyObject * obj2 = 0 ;
14155 PyObject * obj3 = 0 ;
14156 char * kwnames[] = {
14157 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14158 };
14159
14160 arg2 = &temp2;
14161 arg3 = &temp3;
14162 arg4 = &temp4;
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14167 }
14168 arg1 = reinterpret_cast< wxImage * >(argp1);
14169 if (obj1) {
14170 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14171 if (!SWIG_IsOK(ecode5)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14173 }
14174 arg5 = static_cast< byte >(val5);
14175 }
14176 if (obj2) {
14177 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14178 if (!SWIG_IsOK(ecode6)) {
14179 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14180 }
14181 arg6 = static_cast< byte >(val6);
14182 }
14183 if (obj3) {
14184 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14185 if (!SWIG_IsOK(ecode7)) {
14186 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14187 }
14188 arg7 = static_cast< byte >(val7);
14189 }
14190 {
14191 PyThreadState* __tstate = wxPyBeginAllowThreads();
14192 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 {
14197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14198 }
14199 if (SWIG_IsTmpObj(res2)) {
14200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14201 } else {
14202 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14204 }
14205 if (SWIG_IsTmpObj(res3)) {
14206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14207 } else {
14208 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14210 }
14211 if (SWIG_IsTmpObj(res4)) {
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14213 } else {
14214 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14216 }
14217 return resultobj;
14218 fail:
14219 return NULL;
14220 }
14221
14222
14223 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14224 PyObject *resultobj = 0;
14225 wxImage *arg1 = (wxImage *) 0 ;
14226 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14227 bool result;
14228 void *argp1 = 0 ;
14229 int res1 = 0 ;
14230 unsigned char val2 ;
14231 int ecode2 = 0 ;
14232 PyObject * obj0 = 0 ;
14233 PyObject * obj1 = 0 ;
14234 char * kwnames[] = {
14235 (char *) "self",(char *) "threshold", NULL
14236 };
14237
14238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14242 }
14243 arg1 = reinterpret_cast< wxImage * >(argp1);
14244 if (obj1) {
14245 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14246 if (!SWIG_IsOK(ecode2)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14248 }
14249 arg2 = static_cast< byte >(val2);
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 {
14258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14259 }
14260 return resultobj;
14261 fail:
14262 return NULL;
14263 }
14264
14265
14266 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14267 PyObject *resultobj = 0;
14268 wxImage *arg1 = (wxImage *) 0 ;
14269 byte arg2 ;
14270 byte arg3 ;
14271 byte arg4 ;
14272 bool result;
14273 void *argp1 = 0 ;
14274 int res1 = 0 ;
14275 unsigned char val2 ;
14276 int ecode2 = 0 ;
14277 unsigned char val3 ;
14278 int ecode3 = 0 ;
14279 unsigned char val4 ;
14280 int ecode4 = 0 ;
14281 PyObject * obj0 = 0 ;
14282 PyObject * obj1 = 0 ;
14283 PyObject * obj2 = 0 ;
14284 PyObject * obj3 = 0 ;
14285 char * kwnames[] = {
14286 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14287 };
14288
14289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14291 if (!SWIG_IsOK(res1)) {
14292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14293 }
14294 arg1 = reinterpret_cast< wxImage * >(argp1);
14295 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14296 if (!SWIG_IsOK(ecode2)) {
14297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14298 }
14299 arg2 = static_cast< byte >(val2);
14300 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14301 if (!SWIG_IsOK(ecode3)) {
14302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14303 }
14304 arg3 = static_cast< byte >(val3);
14305 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14306 if (!SWIG_IsOK(ecode4)) {
14307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14308 }
14309 arg4 = static_cast< byte >(val4);
14310 {
14311 PyThreadState* __tstate = wxPyBeginAllowThreads();
14312 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14313 wxPyEndAllowThreads(__tstate);
14314 if (PyErr_Occurred()) SWIG_fail;
14315 }
14316 {
14317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14318 }
14319 return resultobj;
14320 fail:
14321 return NULL;
14322 }
14323
14324
14325 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14326 PyObject *resultobj = 0;
14327 wxImage *arg1 = (wxImage *) 0 ;
14328 wxImage *arg2 = 0 ;
14329 byte arg3 ;
14330 byte arg4 ;
14331 byte arg5 ;
14332 bool result;
14333 void *argp1 = 0 ;
14334 int res1 = 0 ;
14335 void *argp2 = 0 ;
14336 int res2 = 0 ;
14337 unsigned char val3 ;
14338 int ecode3 = 0 ;
14339 unsigned char val4 ;
14340 int ecode4 = 0 ;
14341 unsigned char val5 ;
14342 int ecode5 = 0 ;
14343 PyObject * obj0 = 0 ;
14344 PyObject * obj1 = 0 ;
14345 PyObject * obj2 = 0 ;
14346 PyObject * obj3 = 0 ;
14347 PyObject * obj4 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14350 };
14351
14352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14354 if (!SWIG_IsOK(res1)) {
14355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14356 }
14357 arg1 = reinterpret_cast< wxImage * >(argp1);
14358 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14359 if (!SWIG_IsOK(res2)) {
14360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14361 }
14362 if (!argp2) {
14363 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14364 }
14365 arg2 = reinterpret_cast< wxImage * >(argp2);
14366 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14367 if (!SWIG_IsOK(ecode3)) {
14368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14369 }
14370 arg3 = static_cast< byte >(val3);
14371 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14372 if (!SWIG_IsOK(ecode4)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14374 }
14375 arg4 = static_cast< byte >(val4);
14376 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14377 if (!SWIG_IsOK(ecode5)) {
14378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14379 }
14380 arg5 = static_cast< byte >(val5);
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14384 wxPyEndAllowThreads(__tstate);
14385 if (PyErr_Occurred()) SWIG_fail;
14386 }
14387 {
14388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14389 }
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14397 PyObject *resultobj = 0;
14398 wxString *arg1 = 0 ;
14399 bool result;
14400 bool temp1 = false ;
14401 PyObject * obj0 = 0 ;
14402 char * kwnames[] = {
14403 (char *) "filename", NULL
14404 };
14405
14406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14407 {
14408 arg1 = wxString_in_helper(obj0);
14409 if (arg1 == NULL) SWIG_fail;
14410 temp1 = true;
14411 }
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14420 }
14421 {
14422 if (temp1)
14423 delete arg1;
14424 }
14425 return resultobj;
14426 fail:
14427 {
14428 if (temp1)
14429 delete arg1;
14430 }
14431 return NULL;
14432 }
14433
14434
14435 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj = 0;
14437 wxString *arg1 = 0 ;
14438 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14439 int result;
14440 bool temp1 = false ;
14441 long val2 ;
14442 int ecode2 = 0 ;
14443 PyObject * obj0 = 0 ;
14444 PyObject * obj1 = 0 ;
14445 char * kwnames[] = {
14446 (char *) "filename",(char *) "type", NULL
14447 };
14448
14449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14450 {
14451 arg1 = wxString_in_helper(obj0);
14452 if (arg1 == NULL) SWIG_fail;
14453 temp1 = true;
14454 }
14455 if (obj1) {
14456 ecode2 = SWIG_AsVal_long(obj1, &val2);
14457 if (!SWIG_IsOK(ecode2)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14459 }
14460 arg2 = static_cast< long >(val2);
14461 }
14462 {
14463 PyThreadState* __tstate = wxPyBeginAllowThreads();
14464 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = SWIG_From_int(static_cast< int >(result));
14469 {
14470 if (temp1)
14471 delete arg1;
14472 }
14473 return resultobj;
14474 fail:
14475 {
14476 if (temp1)
14477 delete arg1;
14478 }
14479 return NULL;
14480 }
14481
14482
14483 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14484 PyObject *resultobj = 0;
14485 wxImage *arg1 = (wxImage *) 0 ;
14486 wxString *arg2 = 0 ;
14487 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14488 int arg4 = (int) -1 ;
14489 bool result;
14490 void *argp1 = 0 ;
14491 int res1 = 0 ;
14492 bool temp2 = false ;
14493 long val3 ;
14494 int ecode3 = 0 ;
14495 int val4 ;
14496 int ecode4 = 0 ;
14497 PyObject * obj0 = 0 ;
14498 PyObject * obj1 = 0 ;
14499 PyObject * obj2 = 0 ;
14500 PyObject * obj3 = 0 ;
14501 char * kwnames[] = {
14502 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14503 };
14504
14505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14507 if (!SWIG_IsOK(res1)) {
14508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14509 }
14510 arg1 = reinterpret_cast< wxImage * >(argp1);
14511 {
14512 arg2 = wxString_in_helper(obj1);
14513 if (arg2 == NULL) SWIG_fail;
14514 temp2 = true;
14515 }
14516 if (obj2) {
14517 ecode3 = SWIG_AsVal_long(obj2, &val3);
14518 if (!SWIG_IsOK(ecode3)) {
14519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14520 }
14521 arg3 = static_cast< long >(val3);
14522 }
14523 if (obj3) {
14524 ecode4 = SWIG_AsVal_int(obj3, &val4);
14525 if (!SWIG_IsOK(ecode4)) {
14526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14527 }
14528 arg4 = static_cast< int >(val4);
14529 }
14530 {
14531 PyThreadState* __tstate = wxPyBeginAllowThreads();
14532 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14533 wxPyEndAllowThreads(__tstate);
14534 if (PyErr_Occurred()) SWIG_fail;
14535 }
14536 {
14537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14538 }
14539 {
14540 if (temp2)
14541 delete arg2;
14542 }
14543 return resultobj;
14544 fail:
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 return NULL;
14550 }
14551
14552
14553 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14554 PyObject *resultobj = 0;
14555 wxImage *arg1 = (wxImage *) 0 ;
14556 wxString *arg2 = 0 ;
14557 wxString *arg3 = 0 ;
14558 int arg4 = (int) -1 ;
14559 bool result;
14560 void *argp1 = 0 ;
14561 int res1 = 0 ;
14562 bool temp2 = false ;
14563 bool temp3 = false ;
14564 int val4 ;
14565 int ecode4 = 0 ;
14566 PyObject * obj0 = 0 ;
14567 PyObject * obj1 = 0 ;
14568 PyObject * obj2 = 0 ;
14569 PyObject * obj3 = 0 ;
14570 char * kwnames[] = {
14571 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14572 };
14573
14574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14576 if (!SWIG_IsOK(res1)) {
14577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14578 }
14579 arg1 = reinterpret_cast< wxImage * >(argp1);
14580 {
14581 arg2 = wxString_in_helper(obj1);
14582 if (arg2 == NULL) SWIG_fail;
14583 temp2 = true;
14584 }
14585 {
14586 arg3 = wxString_in_helper(obj2);
14587 if (arg3 == NULL) SWIG_fail;
14588 temp3 = true;
14589 }
14590 if (obj3) {
14591 ecode4 = SWIG_AsVal_int(obj3, &val4);
14592 if (!SWIG_IsOK(ecode4)) {
14593 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14594 }
14595 arg4 = static_cast< int >(val4);
14596 }
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14600 wxPyEndAllowThreads(__tstate);
14601 if (PyErr_Occurred()) SWIG_fail;
14602 }
14603 {
14604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14605 }
14606 {
14607 if (temp2)
14608 delete arg2;
14609 }
14610 {
14611 if (temp3)
14612 delete arg3;
14613 }
14614 return resultobj;
14615 fail:
14616 {
14617 if (temp2)
14618 delete arg2;
14619 }
14620 {
14621 if (temp3)
14622 delete arg3;
14623 }
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj = 0;
14630 wxImage *arg1 = (wxImage *) 0 ;
14631 wxString *arg2 = 0 ;
14632 int arg3 ;
14633 bool result;
14634 void *argp1 = 0 ;
14635 int res1 = 0 ;
14636 bool temp2 = false ;
14637 int val3 ;
14638 int ecode3 = 0 ;
14639 PyObject * obj0 = 0 ;
14640 PyObject * obj1 = 0 ;
14641 PyObject * obj2 = 0 ;
14642 char * kwnames[] = {
14643 (char *) "self",(char *) "name",(char *) "type", NULL
14644 };
14645
14646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14648 if (!SWIG_IsOK(res1)) {
14649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14650 }
14651 arg1 = reinterpret_cast< wxImage * >(argp1);
14652 {
14653 arg2 = wxString_in_helper(obj1);
14654 if (arg2 == NULL) SWIG_fail;
14655 temp2 = true;
14656 }
14657 ecode3 = SWIG_AsVal_int(obj2, &val3);
14658 if (!SWIG_IsOK(ecode3)) {
14659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14660 }
14661 arg3 = static_cast< int >(val3);
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 {
14669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14670 }
14671 {
14672 if (temp2)
14673 delete arg2;
14674 }
14675 return resultobj;
14676 fail:
14677 {
14678 if (temp2)
14679 delete arg2;
14680 }
14681 return NULL;
14682 }
14683
14684
14685 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14686 PyObject *resultobj = 0;
14687 wxImage *arg1 = (wxImage *) 0 ;
14688 wxString *arg2 = 0 ;
14689 wxString *arg3 = 0 ;
14690 bool result;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 bool temp2 = false ;
14694 bool temp3 = false ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 PyObject * obj2 = 0 ;
14698 char * kwnames[] = {
14699 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14700 };
14701
14702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14704 if (!SWIG_IsOK(res1)) {
14705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14706 }
14707 arg1 = reinterpret_cast< wxImage * >(argp1);
14708 {
14709 arg2 = wxString_in_helper(obj1);
14710 if (arg2 == NULL) SWIG_fail;
14711 temp2 = true;
14712 }
14713 {
14714 arg3 = wxString_in_helper(obj2);
14715 if (arg3 == NULL) SWIG_fail;
14716 temp3 = true;
14717 }
14718 {
14719 PyThreadState* __tstate = wxPyBeginAllowThreads();
14720 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 {
14732 if (temp3)
14733 delete arg3;
14734 }
14735 return resultobj;
14736 fail:
14737 {
14738 if (temp2)
14739 delete arg2;
14740 }
14741 {
14742 if (temp3)
14743 delete arg3;
14744 }
14745 return NULL;
14746 }
14747
14748
14749 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14750 PyObject *resultobj = 0;
14751 wxInputStream *arg1 = 0 ;
14752 bool result;
14753 wxPyInputStream *temp1 ;
14754 bool created1 ;
14755 PyObject * obj0 = 0 ;
14756 char * kwnames[] = {
14757 (char *) "stream", NULL
14758 };
14759
14760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14761 {
14762 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14763 arg1 = temp1->m_wxis;
14764 created1 = false;
14765 } else {
14766 PyErr_Clear(); // clear the failure of the wxPyConvert above
14767 arg1 = wxPyCBInputStream_create(obj0, false);
14768 if (arg1 == NULL) {
14769 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14770 SWIG_fail;
14771 }
14772 created1 = true;
14773 }
14774 }
14775 {
14776 PyThreadState* __tstate = wxPyBeginAllowThreads();
14777 result = (bool)wxImage::CanRead(*arg1);
14778 wxPyEndAllowThreads(__tstate);
14779 if (PyErr_Occurred()) SWIG_fail;
14780 }
14781 {
14782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14783 }
14784 {
14785 if (created1) delete arg1;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (created1) delete arg1;
14791 }
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxImage *arg1 = (wxImage *) 0 ;
14799 wxInputStream *arg2 = 0 ;
14800 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14801 int arg4 = (int) -1 ;
14802 bool result;
14803 void *argp1 = 0 ;
14804 int res1 = 0 ;
14805 wxPyInputStream *temp2 ;
14806 bool created2 ;
14807 long val3 ;
14808 int ecode3 = 0 ;
14809 int val4 ;
14810 int ecode4 = 0 ;
14811 PyObject * obj0 = 0 ;
14812 PyObject * obj1 = 0 ;
14813 PyObject * obj2 = 0 ;
14814 PyObject * obj3 = 0 ;
14815 char * kwnames[] = {
14816 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14817 };
14818
14819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14821 if (!SWIG_IsOK(res1)) {
14822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14823 }
14824 arg1 = reinterpret_cast< wxImage * >(argp1);
14825 {
14826 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14827 arg2 = temp2->m_wxis;
14828 created2 = false;
14829 } else {
14830 PyErr_Clear(); // clear the failure of the wxPyConvert above
14831 arg2 = wxPyCBInputStream_create(obj1, false);
14832 if (arg2 == NULL) {
14833 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14834 SWIG_fail;
14835 }
14836 created2 = true;
14837 }
14838 }
14839 if (obj2) {
14840 ecode3 = SWIG_AsVal_long(obj2, &val3);
14841 if (!SWIG_IsOK(ecode3)) {
14842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14843 }
14844 arg3 = static_cast< long >(val3);
14845 }
14846 if (obj3) {
14847 ecode4 = SWIG_AsVal_int(obj3, &val4);
14848 if (!SWIG_IsOK(ecode4)) {
14849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14850 }
14851 arg4 = static_cast< int >(val4);
14852 }
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14856 wxPyEndAllowThreads(__tstate);
14857 if (PyErr_Occurred()) SWIG_fail;
14858 }
14859 {
14860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14861 }
14862 {
14863 if (created2) delete arg2;
14864 }
14865 return resultobj;
14866 fail:
14867 {
14868 if (created2) delete arg2;
14869 }
14870 return NULL;
14871 }
14872
14873
14874 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14875 PyObject *resultobj = 0;
14876 wxImage *arg1 = (wxImage *) 0 ;
14877 wxInputStream *arg2 = 0 ;
14878 wxString *arg3 = 0 ;
14879 int arg4 = (int) -1 ;
14880 bool result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 wxPyInputStream *temp2 ;
14884 bool created2 ;
14885 bool temp3 = false ;
14886 int val4 ;
14887 int ecode4 = 0 ;
14888 PyObject * obj0 = 0 ;
14889 PyObject * obj1 = 0 ;
14890 PyObject * obj2 = 0 ;
14891 PyObject * obj3 = 0 ;
14892 char * kwnames[] = {
14893 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14894 };
14895
14896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14898 if (!SWIG_IsOK(res1)) {
14899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14900 }
14901 arg1 = reinterpret_cast< wxImage * >(argp1);
14902 {
14903 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14904 arg2 = temp2->m_wxis;
14905 created2 = false;
14906 } else {
14907 PyErr_Clear(); // clear the failure of the wxPyConvert above
14908 arg2 = wxPyCBInputStream_create(obj1, false);
14909 if (arg2 == NULL) {
14910 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14911 SWIG_fail;
14912 }
14913 created2 = true;
14914 }
14915 }
14916 {
14917 arg3 = wxString_in_helper(obj2);
14918 if (arg3 == NULL) SWIG_fail;
14919 temp3 = true;
14920 }
14921 if (obj3) {
14922 ecode4 = SWIG_AsVal_int(obj3, &val4);
14923 if (!SWIG_IsOK(ecode4)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14925 }
14926 arg4 = static_cast< int >(val4);
14927 }
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 {
14935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14936 }
14937 {
14938 if (created2) delete arg2;
14939 }
14940 {
14941 if (temp3)
14942 delete arg3;
14943 }
14944 return resultobj;
14945 fail:
14946 {
14947 if (created2) delete arg2;
14948 }
14949 {
14950 if (temp3)
14951 delete arg3;
14952 }
14953 return NULL;
14954 }
14955
14956
14957 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14958 PyObject *resultobj = 0;
14959 wxImage *arg1 = (wxImage *) 0 ;
14960 bool result;
14961 void *argp1 = 0 ;
14962 int res1 = 0 ;
14963 PyObject *swig_obj[1] ;
14964
14965 if (!args) SWIG_fail;
14966 swig_obj[0] = args;
14967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14968 if (!SWIG_IsOK(res1)) {
14969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14970 }
14971 arg1 = reinterpret_cast< wxImage * >(argp1);
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (bool)(arg1)->Ok();
14975 wxPyEndAllowThreads(__tstate);
14976 if (PyErr_Occurred()) SWIG_fail;
14977 }
14978 {
14979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14980 }
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14988 PyObject *resultobj = 0;
14989 wxImage *arg1 = (wxImage *) 0 ;
14990 int result;
14991 void *argp1 = 0 ;
14992 int res1 = 0 ;
14993 PyObject *swig_obj[1] ;
14994
14995 if (!args) SWIG_fail;
14996 swig_obj[0] = args;
14997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14998 if (!SWIG_IsOK(res1)) {
14999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15000 }
15001 arg1 = reinterpret_cast< wxImage * >(argp1);
15002 {
15003 PyThreadState* __tstate = wxPyBeginAllowThreads();
15004 result = (int)(arg1)->GetWidth();
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 resultobj = SWIG_From_int(static_cast< int >(result));
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15016 PyObject *resultobj = 0;
15017 wxImage *arg1 = (wxImage *) 0 ;
15018 int result;
15019 void *argp1 = 0 ;
15020 int res1 = 0 ;
15021 PyObject *swig_obj[1] ;
15022
15023 if (!args) SWIG_fail;
15024 swig_obj[0] = args;
15025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15028 }
15029 arg1 = reinterpret_cast< wxImage * >(argp1);
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (int)(arg1)->GetHeight();
15033 wxPyEndAllowThreads(__tstate);
15034 if (PyErr_Occurred()) SWIG_fail;
15035 }
15036 resultobj = SWIG_From_int(static_cast< int >(result));
15037 return resultobj;
15038 fail:
15039 return NULL;
15040 }
15041
15042
15043 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15044 PyObject *resultobj = 0;
15045 wxImage *arg1 = (wxImage *) 0 ;
15046 wxSize result;
15047 void *argp1 = 0 ;
15048 int res1 = 0 ;
15049 PyObject *swig_obj[1] ;
15050
15051 if (!args) SWIG_fail;
15052 swig_obj[0] = args;
15053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15054 if (!SWIG_IsOK(res1)) {
15055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15056 }
15057 arg1 = reinterpret_cast< wxImage * >(argp1);
15058 {
15059 PyThreadState* __tstate = wxPyBeginAllowThreads();
15060 result = wxImage_GetSize(arg1);
15061 wxPyEndAllowThreads(__tstate);
15062 if (PyErr_Occurred()) SWIG_fail;
15063 }
15064 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15065 return resultobj;
15066 fail:
15067 return NULL;
15068 }
15069
15070
15071 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15072 PyObject *resultobj = 0;
15073 wxImage *arg1 = (wxImage *) 0 ;
15074 wxRect *arg2 = 0 ;
15075 SwigValueWrapper<wxImage > result;
15076 void *argp1 = 0 ;
15077 int res1 = 0 ;
15078 wxRect temp2 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 char * kwnames[] = {
15082 (char *) "self",(char *) "rect", NULL
15083 };
15084
15085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15087 if (!SWIG_IsOK(res1)) {
15088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15089 }
15090 arg1 = reinterpret_cast< wxImage * >(argp1);
15091 {
15092 arg2 = &temp2;
15093 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15098 wxPyEndAllowThreads(__tstate);
15099 if (PyErr_Occurred()) SWIG_fail;
15100 }
15101 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15102 return resultobj;
15103 fail:
15104 return NULL;
15105 }
15106
15107
15108 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj = 0;
15110 wxImage *arg1 = (wxImage *) 0 ;
15111 wxSize *arg2 = 0 ;
15112 wxPoint *arg3 = 0 ;
15113 int arg4 = (int) -1 ;
15114 int arg5 = (int) -1 ;
15115 int arg6 = (int) -1 ;
15116 SwigValueWrapper<wxImage > result;
15117 void *argp1 = 0 ;
15118 int res1 = 0 ;
15119 wxSize temp2 ;
15120 wxPoint temp3 ;
15121 int val4 ;
15122 int ecode4 = 0 ;
15123 int val5 ;
15124 int ecode5 = 0 ;
15125 int val6 ;
15126 int ecode6 = 0 ;
15127 PyObject * obj0 = 0 ;
15128 PyObject * obj1 = 0 ;
15129 PyObject * obj2 = 0 ;
15130 PyObject * obj3 = 0 ;
15131 PyObject * obj4 = 0 ;
15132 PyObject * obj5 = 0 ;
15133 char * kwnames[] = {
15134 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15135 };
15136
15137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15139 if (!SWIG_IsOK(res1)) {
15140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15141 }
15142 arg1 = reinterpret_cast< wxImage * >(argp1);
15143 {
15144 arg2 = &temp2;
15145 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15146 }
15147 {
15148 arg3 = &temp3;
15149 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15150 }
15151 if (obj3) {
15152 ecode4 = SWIG_AsVal_int(obj3, &val4);
15153 if (!SWIG_IsOK(ecode4)) {
15154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15155 }
15156 arg4 = static_cast< int >(val4);
15157 }
15158 if (obj4) {
15159 ecode5 = SWIG_AsVal_int(obj4, &val5);
15160 if (!SWIG_IsOK(ecode5)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15162 }
15163 arg5 = static_cast< int >(val5);
15164 }
15165 if (obj5) {
15166 ecode6 = SWIG_AsVal_int(obj5, &val6);
15167 if (!SWIG_IsOK(ecode6)) {
15168 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15169 }
15170 arg6 = static_cast< int >(val6);
15171 }
15172 {
15173 PyThreadState* __tstate = wxPyBeginAllowThreads();
15174 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15179 return resultobj;
15180 fail:
15181 return NULL;
15182 }
15183
15184
15185 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15186 PyObject *resultobj = 0;
15187 wxImage *arg1 = (wxImage *) 0 ;
15188 SwigValueWrapper<wxImage > result;
15189 void *argp1 = 0 ;
15190 int res1 = 0 ;
15191 PyObject *swig_obj[1] ;
15192
15193 if (!args) SWIG_fail;
15194 swig_obj[0] = args;
15195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15196 if (!SWIG_IsOK(res1)) {
15197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15198 }
15199 arg1 = reinterpret_cast< wxImage * >(argp1);
15200 {
15201 PyThreadState* __tstate = wxPyBeginAllowThreads();
15202 result = (arg1)->Copy();
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15207 return resultobj;
15208 fail:
15209 return NULL;
15210 }
15211
15212
15213 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj = 0;
15215 wxImage *arg1 = (wxImage *) 0 ;
15216 wxImage *arg2 = 0 ;
15217 int arg3 ;
15218 int arg4 ;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 void *argp2 = 0 ;
15222 int res2 = 0 ;
15223 int val3 ;
15224 int ecode3 = 0 ;
15225 int val4 ;
15226 int ecode4 = 0 ;
15227 PyObject * obj0 = 0 ;
15228 PyObject * obj1 = 0 ;
15229 PyObject * obj2 = 0 ;
15230 PyObject * obj3 = 0 ;
15231 char * kwnames[] = {
15232 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15233 };
15234
15235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15237 if (!SWIG_IsOK(res1)) {
15238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15239 }
15240 arg1 = reinterpret_cast< wxImage * >(argp1);
15241 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15242 if (!SWIG_IsOK(res2)) {
15243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15244 }
15245 if (!argp2) {
15246 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15247 }
15248 arg2 = reinterpret_cast< wxImage * >(argp2);
15249 ecode3 = SWIG_AsVal_int(obj2, &val3);
15250 if (!SWIG_IsOK(ecode3)) {
15251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15252 }
15253 arg3 = static_cast< int >(val3);
15254 ecode4 = SWIG_AsVal_int(obj3, &val4);
15255 if (!SWIG_IsOK(ecode4)) {
15256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15257 }
15258 arg4 = static_cast< int >(val4);
15259 {
15260 PyThreadState* __tstate = wxPyBeginAllowThreads();
15261 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15262 wxPyEndAllowThreads(__tstate);
15263 if (PyErr_Occurred()) SWIG_fail;
15264 }
15265 resultobj = SWIG_Py_Void();
15266 return resultobj;
15267 fail:
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *resultobj = 0;
15274 wxImage *arg1 = (wxImage *) 0 ;
15275 PyObject *result = 0 ;
15276 void *argp1 = 0 ;
15277 int res1 = 0 ;
15278 PyObject *swig_obj[1] ;
15279
15280 if (!args) SWIG_fail;
15281 swig_obj[0] = args;
15282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15285 }
15286 arg1 = reinterpret_cast< wxImage * >(argp1);
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (PyObject *)wxImage_GetData(arg1);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = result;
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15301 PyObject *resultobj = 0;
15302 wxImage *arg1 = (wxImage *) 0 ;
15303 buffer arg2 ;
15304 int arg3 ;
15305 void *argp1 = 0 ;
15306 int res1 = 0 ;
15307 PyObject * obj0 = 0 ;
15308 PyObject * obj1 = 0 ;
15309 char * kwnames[] = {
15310 (char *) "self",(char *) "data", NULL
15311 };
15312
15313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15315 if (!SWIG_IsOK(res1)) {
15316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15317 }
15318 arg1 = reinterpret_cast< wxImage * >(argp1);
15319 {
15320 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15321 }
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 wxImage_SetData(arg1,arg2,arg3);
15325 wxPyEndAllowThreads(__tstate);
15326 if (PyErr_Occurred()) SWIG_fail;
15327 }
15328 resultobj = SWIG_Py_Void();
15329 return resultobj;
15330 fail:
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxImage *arg1 = (wxImage *) 0 ;
15338 PyObject *result = 0 ;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 PyObject *swig_obj[1] ;
15342
15343 if (!args) SWIG_fail;
15344 swig_obj[0] = args;
15345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15348 }
15349 arg1 = reinterpret_cast< wxImage * >(argp1);
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15353 wxPyEndAllowThreads(__tstate);
15354 if (PyErr_Occurred()) SWIG_fail;
15355 }
15356 resultobj = result;
15357 return resultobj;
15358 fail:
15359 return NULL;
15360 }
15361
15362
15363 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15364 PyObject *resultobj = 0;
15365 wxImage *arg1 = (wxImage *) 0 ;
15366 buffer arg2 ;
15367 int arg3 ;
15368 void *argp1 = 0 ;
15369 int res1 = 0 ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 char * kwnames[] = {
15373 (char *) "self",(char *) "data", NULL
15374 };
15375
15376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15380 }
15381 arg1 = reinterpret_cast< wxImage * >(argp1);
15382 {
15383 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15384 }
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 wxImage_SetDataBuffer(arg1,arg2,arg3);
15388 wxPyEndAllowThreads(__tstate);
15389 if (PyErr_Occurred()) SWIG_fail;
15390 }
15391 resultobj = SWIG_Py_Void();
15392 return resultobj;
15393 fail:
15394 return NULL;
15395 }
15396
15397
15398 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15399 PyObject *resultobj = 0;
15400 wxImage *arg1 = (wxImage *) 0 ;
15401 PyObject *result = 0 ;
15402 void *argp1 = 0 ;
15403 int res1 = 0 ;
15404 PyObject *swig_obj[1] ;
15405
15406 if (!args) SWIG_fail;
15407 swig_obj[0] = args;
15408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage * >(argp1);
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (PyObject *)wxImage_GetAlphaData(arg1);
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 resultobj = result;
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15427 PyObject *resultobj = 0;
15428 wxImage *arg1 = (wxImage *) 0 ;
15429 buffer arg2 ;
15430 int arg3 ;
15431 void *argp1 = 0 ;
15432 int res1 = 0 ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "alpha", NULL
15437 };
15438
15439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15441 if (!SWIG_IsOK(res1)) {
15442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15443 }
15444 arg1 = reinterpret_cast< wxImage * >(argp1);
15445 {
15446 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15447 }
15448 {
15449 PyThreadState* __tstate = wxPyBeginAllowThreads();
15450 wxImage_SetAlphaData(arg1,arg2,arg3);
15451 wxPyEndAllowThreads(__tstate);
15452 if (PyErr_Occurred()) SWIG_fail;
15453 }
15454 resultobj = SWIG_Py_Void();
15455 return resultobj;
15456 fail:
15457 return NULL;
15458 }
15459
15460
15461 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15462 PyObject *resultobj = 0;
15463 wxImage *arg1 = (wxImage *) 0 ;
15464 PyObject *result = 0 ;
15465 void *argp1 = 0 ;
15466 int res1 = 0 ;
15467 PyObject *swig_obj[1] ;
15468
15469 if (!args) SWIG_fail;
15470 swig_obj[0] = args;
15471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15472 if (!SWIG_IsOK(res1)) {
15473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15474 }
15475 arg1 = reinterpret_cast< wxImage * >(argp1);
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15479 wxPyEndAllowThreads(__tstate);
15480 if (PyErr_Occurred()) SWIG_fail;
15481 }
15482 resultobj = result;
15483 return resultobj;
15484 fail:
15485 return NULL;
15486 }
15487
15488
15489 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15490 PyObject *resultobj = 0;
15491 wxImage *arg1 = (wxImage *) 0 ;
15492 buffer arg2 ;
15493 int arg3 ;
15494 void *argp1 = 0 ;
15495 int res1 = 0 ;
15496 PyObject * obj0 = 0 ;
15497 PyObject * obj1 = 0 ;
15498 char * kwnames[] = {
15499 (char *) "self",(char *) "alpha", NULL
15500 };
15501
15502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15506 }
15507 arg1 = reinterpret_cast< wxImage * >(argp1);
15508 {
15509 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15510 }
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15525 PyObject *resultobj = 0;
15526 wxImage *arg1 = (wxImage *) 0 ;
15527 byte arg2 ;
15528 byte arg3 ;
15529 byte arg4 ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 unsigned char val2 ;
15533 int ecode2 = 0 ;
15534 unsigned char val3 ;
15535 int ecode3 = 0 ;
15536 unsigned char val4 ;
15537 int ecode4 = 0 ;
15538 PyObject * obj0 = 0 ;
15539 PyObject * obj1 = 0 ;
15540 PyObject * obj2 = 0 ;
15541 PyObject * obj3 = 0 ;
15542 char * kwnames[] = {
15543 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15544 };
15545
15546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15548 if (!SWIG_IsOK(res1)) {
15549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15550 }
15551 arg1 = reinterpret_cast< wxImage * >(argp1);
15552 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15553 if (!SWIG_IsOK(ecode2)) {
15554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15555 }
15556 arg2 = static_cast< byte >(val2);
15557 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15558 if (!SWIG_IsOK(ecode3)) {
15559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15560 }
15561 arg3 = static_cast< byte >(val3);
15562 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15563 if (!SWIG_IsOK(ecode4)) {
15564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15565 }
15566 arg4 = static_cast< byte >(val4);
15567 {
15568 PyThreadState* __tstate = wxPyBeginAllowThreads();
15569 (arg1)->SetMaskColour(arg2,arg3,arg4);
15570 wxPyEndAllowThreads(__tstate);
15571 if (PyErr_Occurred()) SWIG_fail;
15572 }
15573 resultobj = SWIG_Py_Void();
15574 return resultobj;
15575 fail:
15576 return NULL;
15577 }
15578
15579
15580 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15581 PyObject *resultobj = 0;
15582 wxImage *arg1 = (wxImage *) 0 ;
15583 byte *arg2 = (byte *) 0 ;
15584 byte *arg3 = (byte *) 0 ;
15585 byte *arg4 = (byte *) 0 ;
15586 void *argp1 = 0 ;
15587 int res1 = 0 ;
15588 byte temp2 ;
15589 int res2 = SWIG_TMPOBJ ;
15590 byte temp3 ;
15591 int res3 = SWIG_TMPOBJ ;
15592 byte temp4 ;
15593 int res4 = SWIG_TMPOBJ ;
15594 PyObject *swig_obj[1] ;
15595
15596 arg2 = &temp2;
15597 arg3 = &temp3;
15598 arg4 = &temp4;
15599 if (!args) SWIG_fail;
15600 swig_obj[0] = args;
15601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15602 if (!SWIG_IsOK(res1)) {
15603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15604 }
15605 arg1 = reinterpret_cast< wxImage * >(argp1);
15606 {
15607 PyThreadState* __tstate = wxPyBeginAllowThreads();
15608 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 resultobj = SWIG_Py_Void();
15613 if (SWIG_IsTmpObj(res2)) {
15614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15615 } else {
15616 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15618 }
15619 if (SWIG_IsTmpObj(res3)) {
15620 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15621 } else {
15622 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15623 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15624 }
15625 if (SWIG_IsTmpObj(res4)) {
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15627 } else {
15628 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15630 }
15631 return resultobj;
15632 fail:
15633 return NULL;
15634 }
15635
15636
15637 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15638 PyObject *resultobj = 0;
15639 wxImage *arg1 = (wxImage *) 0 ;
15640 byte result;
15641 void *argp1 = 0 ;
15642 int res1 = 0 ;
15643 PyObject *swig_obj[1] ;
15644
15645 if (!args) SWIG_fail;
15646 swig_obj[0] = args;
15647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15648 if (!SWIG_IsOK(res1)) {
15649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15650 }
15651 arg1 = reinterpret_cast< wxImage * >(argp1);
15652 {
15653 PyThreadState* __tstate = wxPyBeginAllowThreads();
15654 result = (byte)(arg1)->GetMaskRed();
15655 wxPyEndAllowThreads(__tstate);
15656 if (PyErr_Occurred()) SWIG_fail;
15657 }
15658 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15666 PyObject *resultobj = 0;
15667 wxImage *arg1 = (wxImage *) 0 ;
15668 byte result;
15669 void *argp1 = 0 ;
15670 int res1 = 0 ;
15671 PyObject *swig_obj[1] ;
15672
15673 if (!args) SWIG_fail;
15674 swig_obj[0] = args;
15675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15676 if (!SWIG_IsOK(res1)) {
15677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15678 }
15679 arg1 = reinterpret_cast< wxImage * >(argp1);
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = (byte)(arg1)->GetMaskGreen();
15683 wxPyEndAllowThreads(__tstate);
15684 if (PyErr_Occurred()) SWIG_fail;
15685 }
15686 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15687 return resultobj;
15688 fail:
15689 return NULL;
15690 }
15691
15692
15693 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15694 PyObject *resultobj = 0;
15695 wxImage *arg1 = (wxImage *) 0 ;
15696 byte result;
15697 void *argp1 = 0 ;
15698 int res1 = 0 ;
15699 PyObject *swig_obj[1] ;
15700
15701 if (!args) SWIG_fail;
15702 swig_obj[0] = args;
15703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15704 if (!SWIG_IsOK(res1)) {
15705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15706 }
15707 arg1 = reinterpret_cast< wxImage * >(argp1);
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (byte)(arg1)->GetMaskBlue();
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15722 PyObject *resultobj = 0;
15723 wxImage *arg1 = (wxImage *) 0 ;
15724 bool arg2 = (bool) true ;
15725 void *argp1 = 0 ;
15726 int res1 = 0 ;
15727 bool val2 ;
15728 int ecode2 = 0 ;
15729 PyObject * obj0 = 0 ;
15730 PyObject * obj1 = 0 ;
15731 char * kwnames[] = {
15732 (char *) "self",(char *) "mask", NULL
15733 };
15734
15735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15737 if (!SWIG_IsOK(res1)) {
15738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15739 }
15740 arg1 = reinterpret_cast< wxImage * >(argp1);
15741 if (obj1) {
15742 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15745 }
15746 arg2 = static_cast< bool >(val2);
15747 }
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 (arg1)->SetMask(arg2);
15751 wxPyEndAllowThreads(__tstate);
15752 if (PyErr_Occurred()) SWIG_fail;
15753 }
15754 resultobj = SWIG_Py_Void();
15755 return resultobj;
15756 fail:
15757 return NULL;
15758 }
15759
15760
15761 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15762 PyObject *resultobj = 0;
15763 wxImage *arg1 = (wxImage *) 0 ;
15764 bool result;
15765 void *argp1 = 0 ;
15766 int res1 = 0 ;
15767 PyObject *swig_obj[1] ;
15768
15769 if (!args) SWIG_fail;
15770 swig_obj[0] = args;
15771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15772 if (!SWIG_IsOK(res1)) {
15773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15774 }
15775 arg1 = reinterpret_cast< wxImage * >(argp1);
15776 {
15777 PyThreadState* __tstate = wxPyBeginAllowThreads();
15778 result = (bool)(arg1)->HasMask();
15779 wxPyEndAllowThreads(__tstate);
15780 if (PyErr_Occurred()) SWIG_fail;
15781 }
15782 {
15783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15784 }
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15792 PyObject *resultobj = 0;
15793 wxImage *arg1 = (wxImage *) 0 ;
15794 double arg2 ;
15795 wxPoint *arg3 = 0 ;
15796 bool arg4 = (bool) true ;
15797 wxPoint *arg5 = (wxPoint *) NULL ;
15798 SwigValueWrapper<wxImage > result;
15799 void *argp1 = 0 ;
15800 int res1 = 0 ;
15801 double val2 ;
15802 int ecode2 = 0 ;
15803 wxPoint temp3 ;
15804 bool val4 ;
15805 int ecode4 = 0 ;
15806 void *argp5 = 0 ;
15807 int res5 = 0 ;
15808 PyObject * obj0 = 0 ;
15809 PyObject * obj1 = 0 ;
15810 PyObject * obj2 = 0 ;
15811 PyObject * obj3 = 0 ;
15812 PyObject * obj4 = 0 ;
15813 char * kwnames[] = {
15814 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15815 };
15816
15817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15819 if (!SWIG_IsOK(res1)) {
15820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15821 }
15822 arg1 = reinterpret_cast< wxImage * >(argp1);
15823 ecode2 = SWIG_AsVal_double(obj1, &val2);
15824 if (!SWIG_IsOK(ecode2)) {
15825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15826 }
15827 arg2 = static_cast< double >(val2);
15828 {
15829 arg3 = &temp3;
15830 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15831 }
15832 if (obj3) {
15833 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15834 if (!SWIG_IsOK(ecode4)) {
15835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15836 }
15837 arg4 = static_cast< bool >(val4);
15838 }
15839 if (obj4) {
15840 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15841 if (!SWIG_IsOK(res5)) {
15842 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15843 }
15844 arg5 = reinterpret_cast< wxPoint * >(argp5);
15845 }
15846 {
15847 PyThreadState* __tstate = wxPyBeginAllowThreads();
15848 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15849 wxPyEndAllowThreads(__tstate);
15850 if (PyErr_Occurred()) SWIG_fail;
15851 }
15852 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15860 PyObject *resultobj = 0;
15861 wxImage *arg1 = (wxImage *) 0 ;
15862 bool arg2 = (bool) true ;
15863 SwigValueWrapper<wxImage > result;
15864 void *argp1 = 0 ;
15865 int res1 = 0 ;
15866 bool val2 ;
15867 int ecode2 = 0 ;
15868 PyObject * obj0 = 0 ;
15869 PyObject * obj1 = 0 ;
15870 char * kwnames[] = {
15871 (char *) "self",(char *) "clockwise", NULL
15872 };
15873
15874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15876 if (!SWIG_IsOK(res1)) {
15877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15878 }
15879 arg1 = reinterpret_cast< wxImage * >(argp1);
15880 if (obj1) {
15881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15882 if (!SWIG_IsOK(ecode2)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15884 }
15885 arg2 = static_cast< bool >(val2);
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (arg1)->Rotate90(arg2);
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj = 0;
15902 wxImage *arg1 = (wxImage *) 0 ;
15903 bool arg2 = (bool) true ;
15904 SwigValueWrapper<wxImage > result;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 bool val2 ;
15908 int ecode2 = 0 ;
15909 PyObject * obj0 = 0 ;
15910 PyObject * obj1 = 0 ;
15911 char * kwnames[] = {
15912 (char *) "self",(char *) "horizontally", NULL
15913 };
15914
15915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15917 if (!SWIG_IsOK(res1)) {
15918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15919 }
15920 arg1 = reinterpret_cast< wxImage * >(argp1);
15921 if (obj1) {
15922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15923 if (!SWIG_IsOK(ecode2)) {
15924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15925 }
15926 arg2 = static_cast< bool >(val2);
15927 }
15928 {
15929 PyThreadState* __tstate = wxPyBeginAllowThreads();
15930 result = (arg1)->Mirror(arg2);
15931 wxPyEndAllowThreads(__tstate);
15932 if (PyErr_Occurred()) SWIG_fail;
15933 }
15934 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15935 return resultobj;
15936 fail:
15937 return NULL;
15938 }
15939
15940
15941 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15942 PyObject *resultobj = 0;
15943 wxImage *arg1 = (wxImage *) 0 ;
15944 byte arg2 ;
15945 byte arg3 ;
15946 byte arg4 ;
15947 byte arg5 ;
15948 byte arg6 ;
15949 byte arg7 ;
15950 void *argp1 = 0 ;
15951 int res1 = 0 ;
15952 unsigned char val2 ;
15953 int ecode2 = 0 ;
15954 unsigned char val3 ;
15955 int ecode3 = 0 ;
15956 unsigned char val4 ;
15957 int ecode4 = 0 ;
15958 unsigned char val5 ;
15959 int ecode5 = 0 ;
15960 unsigned char val6 ;
15961 int ecode6 = 0 ;
15962 unsigned char val7 ;
15963 int ecode7 = 0 ;
15964 PyObject * obj0 = 0 ;
15965 PyObject * obj1 = 0 ;
15966 PyObject * obj2 = 0 ;
15967 PyObject * obj3 = 0 ;
15968 PyObject * obj4 = 0 ;
15969 PyObject * obj5 = 0 ;
15970 PyObject * obj6 = 0 ;
15971 char * kwnames[] = {
15972 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15973 };
15974
15975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15977 if (!SWIG_IsOK(res1)) {
15978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15979 }
15980 arg1 = reinterpret_cast< wxImage * >(argp1);
15981 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15982 if (!SWIG_IsOK(ecode2)) {
15983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15984 }
15985 arg2 = static_cast< byte >(val2);
15986 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15987 if (!SWIG_IsOK(ecode3)) {
15988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15989 }
15990 arg3 = static_cast< byte >(val3);
15991 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15992 if (!SWIG_IsOK(ecode4)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15994 }
15995 arg4 = static_cast< byte >(val4);
15996 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15997 if (!SWIG_IsOK(ecode5)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15999 }
16000 arg5 = static_cast< byte >(val5);
16001 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16002 if (!SWIG_IsOK(ecode6)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16004 }
16005 arg6 = static_cast< byte >(val6);
16006 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16007 if (!SWIG_IsOK(ecode7)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16009 }
16010 arg7 = static_cast< byte >(val7);
16011 {
16012 PyThreadState* __tstate = wxPyBeginAllowThreads();
16013 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
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_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16025 PyObject *resultobj = 0;
16026 wxImage *arg1 = (wxImage *) 0 ;
16027 double arg2 = (double) 0.299 ;
16028 double arg3 = (double) 0.587 ;
16029 double arg4 = (double) 0.114 ;
16030 SwigValueWrapper<wxImage > result;
16031 void *argp1 = 0 ;
16032 int res1 = 0 ;
16033 double val2 ;
16034 int ecode2 = 0 ;
16035 double val3 ;
16036 int ecode3 = 0 ;
16037 double val4 ;
16038 int ecode4 = 0 ;
16039 PyObject * obj0 = 0 ;
16040 PyObject * obj1 = 0 ;
16041 PyObject * obj2 = 0 ;
16042 PyObject * obj3 = 0 ;
16043 char * kwnames[] = {
16044 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16045 };
16046
16047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16049 if (!SWIG_IsOK(res1)) {
16050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16051 }
16052 arg1 = reinterpret_cast< wxImage * >(argp1);
16053 if (obj1) {
16054 ecode2 = SWIG_AsVal_double(obj1, &val2);
16055 if (!SWIG_IsOK(ecode2)) {
16056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16057 }
16058 arg2 = static_cast< double >(val2);
16059 }
16060 if (obj2) {
16061 ecode3 = SWIG_AsVal_double(obj2, &val3);
16062 if (!SWIG_IsOK(ecode3)) {
16063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16064 }
16065 arg3 = static_cast< double >(val3);
16066 }
16067 if (obj3) {
16068 ecode4 = SWIG_AsVal_double(obj3, &val4);
16069 if (!SWIG_IsOK(ecode4)) {
16070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16071 }
16072 arg4 = static_cast< double >(val4);
16073 }
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj = 0;
16089 wxImage *arg1 = (wxImage *) 0 ;
16090 byte arg2 ;
16091 byte arg3 ;
16092 byte arg4 ;
16093 SwigValueWrapper<wxImage > result;
16094 void *argp1 = 0 ;
16095 int res1 = 0 ;
16096 unsigned char val2 ;
16097 int ecode2 = 0 ;
16098 unsigned char val3 ;
16099 int ecode3 = 0 ;
16100 unsigned char val4 ;
16101 int ecode4 = 0 ;
16102 PyObject * obj0 = 0 ;
16103 PyObject * obj1 = 0 ;
16104 PyObject * obj2 = 0 ;
16105 PyObject * obj3 = 0 ;
16106 char * kwnames[] = {
16107 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16108 };
16109
16110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16112 if (!SWIG_IsOK(res1)) {
16113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16114 }
16115 arg1 = reinterpret_cast< wxImage * >(argp1);
16116 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16117 if (!SWIG_IsOK(ecode2)) {
16118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16119 }
16120 arg2 = static_cast< byte >(val2);
16121 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16122 if (!SWIG_IsOK(ecode3)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16124 }
16125 arg3 = static_cast< byte >(val3);
16126 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16127 if (!SWIG_IsOK(ecode4)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16129 }
16130 arg4 = static_cast< byte >(val4);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = 0;
16146 wxImage *arg1 = (wxImage *) 0 ;
16147 wxString *arg2 = 0 ;
16148 wxString *arg3 = 0 ;
16149 void *argp1 = 0 ;
16150 int res1 = 0 ;
16151 bool temp2 = false ;
16152 bool temp3 = false ;
16153 PyObject * obj0 = 0 ;
16154 PyObject * obj1 = 0 ;
16155 PyObject * obj2 = 0 ;
16156 char * kwnames[] = {
16157 (char *) "self",(char *) "name",(char *) "value", NULL
16158 };
16159
16160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16162 if (!SWIG_IsOK(res1)) {
16163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16164 }
16165 arg1 = reinterpret_cast< wxImage * >(argp1);
16166 {
16167 arg2 = wxString_in_helper(obj1);
16168 if (arg2 == NULL) SWIG_fail;
16169 temp2 = true;
16170 }
16171 {
16172 arg3 = wxString_in_helper(obj2);
16173 if (arg3 == NULL) SWIG_fail;
16174 temp3 = true;
16175 }
16176 {
16177 PyThreadState* __tstate = wxPyBeginAllowThreads();
16178 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16179 wxPyEndAllowThreads(__tstate);
16180 if (PyErr_Occurred()) SWIG_fail;
16181 }
16182 resultobj = SWIG_Py_Void();
16183 {
16184 if (temp2)
16185 delete arg2;
16186 }
16187 {
16188 if (temp3)
16189 delete arg3;
16190 }
16191 return resultobj;
16192 fail:
16193 {
16194 if (temp2)
16195 delete arg2;
16196 }
16197 {
16198 if (temp3)
16199 delete arg3;
16200 }
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 wxString *arg2 = 0 ;
16209 int arg3 ;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 bool temp2 = false ;
16213 int val3 ;
16214 int ecode3 = 0 ;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 PyObject * obj2 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "name",(char *) "value", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 {
16229 arg2 = wxString_in_helper(obj1);
16230 if (arg2 == NULL) SWIG_fail;
16231 temp2 = true;
16232 }
16233 ecode3 = SWIG_AsVal_int(obj2, &val3);
16234 if (!SWIG_IsOK(ecode3)) {
16235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16236 }
16237 arg3 = static_cast< int >(val3);
16238 {
16239 PyThreadState* __tstate = wxPyBeginAllowThreads();
16240 (arg1)->SetOption((wxString const &)*arg2,arg3);
16241 wxPyEndAllowThreads(__tstate);
16242 if (PyErr_Occurred()) SWIG_fail;
16243 }
16244 resultobj = SWIG_Py_Void();
16245 {
16246 if (temp2)
16247 delete arg2;
16248 }
16249 return resultobj;
16250 fail:
16251 {
16252 if (temp2)
16253 delete arg2;
16254 }
16255 return NULL;
16256 }
16257
16258
16259 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16260 PyObject *resultobj = 0;
16261 wxImage *arg1 = (wxImage *) 0 ;
16262 wxString *arg2 = 0 ;
16263 wxString result;
16264 void *argp1 = 0 ;
16265 int res1 = 0 ;
16266 bool temp2 = false ;
16267 PyObject * obj0 = 0 ;
16268 PyObject * obj1 = 0 ;
16269 char * kwnames[] = {
16270 (char *) "self",(char *) "name", NULL
16271 };
16272
16273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16275 if (!SWIG_IsOK(res1)) {
16276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16277 }
16278 arg1 = reinterpret_cast< wxImage * >(argp1);
16279 {
16280 arg2 = wxString_in_helper(obj1);
16281 if (arg2 == NULL) SWIG_fail;
16282 temp2 = true;
16283 }
16284 {
16285 PyThreadState* __tstate = wxPyBeginAllowThreads();
16286 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16287 wxPyEndAllowThreads(__tstate);
16288 if (PyErr_Occurred()) SWIG_fail;
16289 }
16290 {
16291 #if wxUSE_UNICODE
16292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16293 #else
16294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16295 #endif
16296 }
16297 {
16298 if (temp2)
16299 delete arg2;
16300 }
16301 return resultobj;
16302 fail:
16303 {
16304 if (temp2)
16305 delete arg2;
16306 }
16307 return NULL;
16308 }
16309
16310
16311 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj = 0;
16313 wxImage *arg1 = (wxImage *) 0 ;
16314 wxString *arg2 = 0 ;
16315 int result;
16316 void *argp1 = 0 ;
16317 int res1 = 0 ;
16318 bool temp2 = false ;
16319 PyObject * obj0 = 0 ;
16320 PyObject * obj1 = 0 ;
16321 char * kwnames[] = {
16322 (char *) "self",(char *) "name", NULL
16323 };
16324
16325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16327 if (!SWIG_IsOK(res1)) {
16328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16329 }
16330 arg1 = reinterpret_cast< wxImage * >(argp1);
16331 {
16332 arg2 = wxString_in_helper(obj1);
16333 if (arg2 == NULL) SWIG_fail;
16334 temp2 = true;
16335 }
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16339 wxPyEndAllowThreads(__tstate);
16340 if (PyErr_Occurred()) SWIG_fail;
16341 }
16342 resultobj = SWIG_From_int(static_cast< int >(result));
16343 {
16344 if (temp2)
16345 delete arg2;
16346 }
16347 return resultobj;
16348 fail:
16349 {
16350 if (temp2)
16351 delete arg2;
16352 }
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 wxString *arg2 = 0 ;
16361 bool result;
16362 void *argp1 = 0 ;
16363 int res1 = 0 ;
16364 bool temp2 = false ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 char * kwnames[] = {
16368 (char *) "self",(char *) "name", NULL
16369 };
16370
16371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16373 if (!SWIG_IsOK(res1)) {
16374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16375 }
16376 arg1 = reinterpret_cast< wxImage * >(argp1);
16377 {
16378 arg2 = wxString_in_helper(obj1);
16379 if (arg2 == NULL) SWIG_fail;
16380 temp2 = true;
16381 }
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 {
16389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16390 }
16391 {
16392 if (temp2)
16393 delete arg2;
16394 }
16395 return resultobj;
16396 fail:
16397 {
16398 if (temp2)
16399 delete arg2;
16400 }
16401 return NULL;
16402 }
16403
16404
16405 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16406 PyObject *resultobj = 0;
16407 wxImage *arg1 = (wxImage *) 0 ;
16408 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16409 unsigned long result;
16410 void *argp1 = 0 ;
16411 int res1 = 0 ;
16412 unsigned long val2 ;
16413 int ecode2 = 0 ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 char * kwnames[] = {
16417 (char *) "self",(char *) "stopafter", NULL
16418 };
16419
16420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16422 if (!SWIG_IsOK(res1)) {
16423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16424 }
16425 arg1 = reinterpret_cast< wxImage * >(argp1);
16426 if (obj1) {
16427 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16428 if (!SWIG_IsOK(ecode2)) {
16429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16430 }
16431 arg2 = static_cast< unsigned long >(val2);
16432 }
16433 {
16434 PyThreadState* __tstate = wxPyBeginAllowThreads();
16435 result = (unsigned long)(arg1)->CountColours(arg2);
16436 wxPyEndAllowThreads(__tstate);
16437 if (PyErr_Occurred()) SWIG_fail;
16438 }
16439 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16440 return resultobj;
16441 fail:
16442 return NULL;
16443 }
16444
16445
16446 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16447 PyObject *resultobj = 0;
16448 wxImage *arg1 = (wxImage *) 0 ;
16449 wxImageHistogram *arg2 = 0 ;
16450 unsigned long result;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 void *argp2 = 0 ;
16454 int res2 = 0 ;
16455 PyObject * obj0 = 0 ;
16456 PyObject * obj1 = 0 ;
16457 char * kwnames[] = {
16458 (char *) "self",(char *) "h", NULL
16459 };
16460
16461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16463 if (!SWIG_IsOK(res1)) {
16464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16465 }
16466 arg1 = reinterpret_cast< wxImage * >(argp1);
16467 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16468 if (!SWIG_IsOK(res2)) {
16469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16470 }
16471 if (!argp2) {
16472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16473 }
16474 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16482 return resultobj;
16483 fail:
16484 return NULL;
16485 }
16486
16487
16488 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj = 0;
16490 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16491 void *argp1 = 0 ;
16492 int res1 = 0 ;
16493 PyObject * obj0 = 0 ;
16494 char * kwnames[] = {
16495 (char *) "handler", NULL
16496 };
16497
16498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16502 }
16503 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16504 {
16505 PyThreadState* __tstate = wxPyBeginAllowThreads();
16506 wxImage::AddHandler(arg1);
16507 wxPyEndAllowThreads(__tstate);
16508 if (PyErr_Occurred()) SWIG_fail;
16509 }
16510 resultobj = SWIG_Py_Void();
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj = 0;
16519 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16520 void *argp1 = 0 ;
16521 int res1 = 0 ;
16522 PyObject * obj0 = 0 ;
16523 char * kwnames[] = {
16524 (char *) "handler", NULL
16525 };
16526
16527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16529 if (!SWIG_IsOK(res1)) {
16530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16531 }
16532 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16533 {
16534 PyThreadState* __tstate = wxPyBeginAllowThreads();
16535 wxImage::InsertHandler(arg1);
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 resultobj = SWIG_Py_Void();
16540 return resultobj;
16541 fail:
16542 return NULL;
16543 }
16544
16545
16546 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16547 PyObject *resultobj = 0;
16548 wxString *arg1 = 0 ;
16549 bool result;
16550 bool temp1 = false ;
16551 PyObject * obj0 = 0 ;
16552 char * kwnames[] = {
16553 (char *) "name", NULL
16554 };
16555
16556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16557 {
16558 arg1 = wxString_in_helper(obj0);
16559 if (arg1 == NULL) SWIG_fail;
16560 temp1 = true;
16561 }
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 {
16569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16570 }
16571 {
16572 if (temp1)
16573 delete arg1;
16574 }
16575 return resultobj;
16576 fail:
16577 {
16578 if (temp1)
16579 delete arg1;
16580 }
16581 return NULL;
16582 }
16583
16584
16585 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16586 PyObject *resultobj = 0;
16587 PyObject *result = 0 ;
16588
16589 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16590 {
16591 PyThreadState* __tstate = wxPyBeginAllowThreads();
16592 result = (PyObject *)wxImage_GetHandlers();
16593 wxPyEndAllowThreads(__tstate);
16594 if (PyErr_Occurred()) SWIG_fail;
16595 }
16596 resultobj = result;
16597 return resultobj;
16598 fail:
16599 return NULL;
16600 }
16601
16602
16603 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16604 PyObject *resultobj = 0;
16605 wxString result;
16606
16607 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 result = wxImage::GetImageExtWildcard();
16611 wxPyEndAllowThreads(__tstate);
16612 if (PyErr_Occurred()) SWIG_fail;
16613 }
16614 {
16615 #if wxUSE_UNICODE
16616 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16617 #else
16618 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16619 #endif
16620 }
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj = 0;
16629 wxImage *arg1 = (wxImage *) 0 ;
16630 int arg2 = (int) -1 ;
16631 wxBitmap result;
16632 void *argp1 = 0 ;
16633 int res1 = 0 ;
16634 int val2 ;
16635 int ecode2 = 0 ;
16636 PyObject * obj0 = 0 ;
16637 PyObject * obj1 = 0 ;
16638 char * kwnames[] = {
16639 (char *) "self",(char *) "depth", NULL
16640 };
16641
16642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16644 if (!SWIG_IsOK(res1)) {
16645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16646 }
16647 arg1 = reinterpret_cast< wxImage * >(argp1);
16648 if (obj1) {
16649 ecode2 = SWIG_AsVal_int(obj1, &val2);
16650 if (!SWIG_IsOK(ecode2)) {
16651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16652 }
16653 arg2 = static_cast< int >(val2);
16654 }
16655 {
16656 if (!wxPyCheckForApp()) SWIG_fail;
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 result = wxImage_ConvertToBitmap(arg1,arg2);
16659 wxPyEndAllowThreads(__tstate);
16660 if (PyErr_Occurred()) SWIG_fail;
16661 }
16662 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16663 return resultobj;
16664 fail:
16665 return NULL;
16666 }
16667
16668
16669 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj = 0;
16671 wxImage *arg1 = (wxImage *) 0 ;
16672 byte arg2 ;
16673 byte arg3 ;
16674 byte arg4 ;
16675 wxBitmap result;
16676 void *argp1 = 0 ;
16677 int res1 = 0 ;
16678 unsigned char val2 ;
16679 int ecode2 = 0 ;
16680 unsigned char val3 ;
16681 int ecode3 = 0 ;
16682 unsigned char val4 ;
16683 int ecode4 = 0 ;
16684 PyObject * obj0 = 0 ;
16685 PyObject * obj1 = 0 ;
16686 PyObject * obj2 = 0 ;
16687 PyObject * obj3 = 0 ;
16688 char * kwnames[] = {
16689 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16690 };
16691
16692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16694 if (!SWIG_IsOK(res1)) {
16695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16696 }
16697 arg1 = reinterpret_cast< wxImage * >(argp1);
16698 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16699 if (!SWIG_IsOK(ecode2)) {
16700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16701 }
16702 arg2 = static_cast< byte >(val2);
16703 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16704 if (!SWIG_IsOK(ecode3)) {
16705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16706 }
16707 arg3 = static_cast< byte >(val3);
16708 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16709 if (!SWIG_IsOK(ecode4)) {
16710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16711 }
16712 arg4 = static_cast< byte >(val4);
16713 {
16714 if (!wxPyCheckForApp()) SWIG_fail;
16715 PyThreadState* __tstate = wxPyBeginAllowThreads();
16716 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16717 wxPyEndAllowThreads(__tstate);
16718 if (PyErr_Occurred()) SWIG_fail;
16719 }
16720 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16721 return resultobj;
16722 fail:
16723 return NULL;
16724 }
16725
16726
16727 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16728 PyObject *resultobj = 0;
16729 wxImage *arg1 = (wxImage *) 0 ;
16730 double arg2 ;
16731 void *argp1 = 0 ;
16732 int res1 = 0 ;
16733 double val2 ;
16734 int ecode2 = 0 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 char * kwnames[] = {
16738 (char *) "self",(char *) "angle", NULL
16739 };
16740
16741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16743 if (!SWIG_IsOK(res1)) {
16744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16745 }
16746 arg1 = reinterpret_cast< wxImage * >(argp1);
16747 ecode2 = SWIG_AsVal_double(obj1, &val2);
16748 if (!SWIG_IsOK(ecode2)) {
16749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16750 }
16751 arg2 = static_cast< double >(val2);
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 (arg1)->RotateHue(arg2);
16755 wxPyEndAllowThreads(__tstate);
16756 if (PyErr_Occurred()) SWIG_fail;
16757 }
16758 resultobj = SWIG_Py_Void();
16759 return resultobj;
16760 fail:
16761 return NULL;
16762 }
16763
16764
16765 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16766 PyObject *resultobj = 0;
16767 wxImage_RGBValue arg1 ;
16768 wxImage_HSVValue result;
16769 void *argp1 ;
16770 int res1 = 0 ;
16771 PyObject * obj0 = 0 ;
16772 char * kwnames[] = {
16773 (char *) "rgb", NULL
16774 };
16775
16776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16777 {
16778 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16779 if (!SWIG_IsOK(res1)) {
16780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16781 }
16782 if (!argp1) {
16783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16784 } else {
16785 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16786 arg1 = *temp;
16787 if (SWIG_IsNewObj(res1)) delete temp;
16788 }
16789 }
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = wxImage::RGBtoHSV(arg1);
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj = 0;
16805 wxImage_HSVValue arg1 ;
16806 wxImage_RGBValue result;
16807 void *argp1 ;
16808 int res1 = 0 ;
16809 PyObject * obj0 = 0 ;
16810 char * kwnames[] = {
16811 (char *) "hsv", NULL
16812 };
16813
16814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16815 {
16816 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16819 }
16820 if (!argp1) {
16821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16822 } else {
16823 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16824 arg1 = *temp;
16825 if (SWIG_IsNewObj(res1)) delete temp;
16826 }
16827 }
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 result = wxImage::HSVtoRGB(arg1);
16831 wxPyEndAllowThreads(__tstate);
16832 if (PyErr_Occurred()) SWIG_fail;
16833 }
16834 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16835 return resultobj;
16836 fail:
16837 return NULL;
16838 }
16839
16840
16841 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16842 PyObject *obj;
16843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16844 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16845 return SWIG_Py_Void();
16846 }
16847
16848 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16849 return SWIG_Python_InitShadowInstance(args);
16850 }
16851
16852 SWIGINTERN int NullImage_set(PyObject *) {
16853 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16854 return 1;
16855 }
16856
16857
16858 SWIGINTERN PyObject *NullImage_get(void) {
16859 PyObject *pyobj = 0;
16860
16861 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16862 return pyobj;
16863 }
16864
16865
16866 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16867 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16868 return 1;
16869 }
16870
16871
16872 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16873 PyObject *pyobj = 0;
16874
16875 {
16876 #if wxUSE_UNICODE
16877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16878 #else
16879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16880 #endif
16881 }
16882 return pyobj;
16883 }
16884
16885
16886 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16888 return 1;
16889 }
16890
16891
16892 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16893 PyObject *pyobj = 0;
16894
16895 {
16896 #if wxUSE_UNICODE
16897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16898 #else
16899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16900 #endif
16901 }
16902 return pyobj;
16903 }
16904
16905
16906 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16908 return 1;
16909 }
16910
16911
16912 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16913 PyObject *pyobj = 0;
16914
16915 {
16916 #if wxUSE_UNICODE
16917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16918 #else
16919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16920 #endif
16921 }
16922 return pyobj;
16923 }
16924
16925
16926 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16928 return 1;
16929 }
16930
16931
16932 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16933 PyObject *pyobj = 0;
16934
16935 {
16936 #if wxUSE_UNICODE
16937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16938 #else
16939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16940 #endif
16941 }
16942 return pyobj;
16943 }
16944
16945
16946 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16948 return 1;
16949 }
16950
16951
16952 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16953 PyObject *pyobj = 0;
16954
16955 {
16956 #if wxUSE_UNICODE
16957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16958 #else
16959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16960 #endif
16961 }
16962 return pyobj;
16963 }
16964
16965
16966 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16968 return 1;
16969 }
16970
16971
16972 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16973 PyObject *pyobj = 0;
16974
16975 {
16976 #if wxUSE_UNICODE
16977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16978 #else
16979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16980 #endif
16981 }
16982 return pyobj;
16983 }
16984
16985
16986 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16988 return 1;
16989 }
16990
16991
16992 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16993 PyObject *pyobj = 0;
16994
16995 {
16996 #if wxUSE_UNICODE
16997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16998 #else
16999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17000 #endif
17001 }
17002 return pyobj;
17003 }
17004
17005
17006 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17008 return 1;
17009 }
17010
17011
17012 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17013 PyObject *pyobj = 0;
17014
17015 {
17016 #if wxUSE_UNICODE
17017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17018 #else
17019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17020 #endif
17021 }
17022 return pyobj;
17023 }
17024
17025
17026 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17028 return 1;
17029 }
17030
17031
17032 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17033 PyObject *pyobj = 0;
17034
17035 {
17036 #if wxUSE_UNICODE
17037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17038 #else
17039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17040 #endif
17041 }
17042 return pyobj;
17043 }
17044
17045
17046 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17048 return 1;
17049 }
17050
17051
17052 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17053 PyObject *pyobj = 0;
17054
17055 {
17056 #if wxUSE_UNICODE
17057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17058 #else
17059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17060 #endif
17061 }
17062 return pyobj;
17063 }
17064
17065
17066 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17068 return 1;
17069 }
17070
17071
17072 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17073 PyObject *pyobj = 0;
17074
17075 {
17076 #if wxUSE_UNICODE
17077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17078 #else
17079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17080 #endif
17081 }
17082 return pyobj;
17083 }
17084
17085
17086 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17087 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17088 return 1;
17089 }
17090
17091
17092 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17093 PyObject *pyobj = 0;
17094
17095 {
17096 #if wxUSE_UNICODE
17097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17098 #else
17099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17100 #endif
17101 }
17102 return pyobj;
17103 }
17104
17105
17106 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17107 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17108 return 1;
17109 }
17110
17111
17112 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17113 PyObject *pyobj = 0;
17114
17115 {
17116 #if wxUSE_UNICODE
17117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17118 #else
17119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17120 #endif
17121 }
17122 return pyobj;
17123 }
17124
17125
17126 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17127 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17128 return 1;
17129 }
17130
17131
17132 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17133 PyObject *pyobj = 0;
17134
17135 {
17136 #if wxUSE_UNICODE
17137 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17138 #else
17139 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17140 #endif
17141 }
17142 return pyobj;
17143 }
17144
17145
17146 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17147 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17148 return 1;
17149 }
17150
17151
17152 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17153 PyObject *pyobj = 0;
17154
17155 {
17156 #if wxUSE_UNICODE
17157 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17158 #else
17159 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17160 #endif
17161 }
17162 return pyobj;
17163 }
17164
17165
17166 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17167 PyObject *resultobj = 0;
17168 wxBMPHandler *result = 0 ;
17169
17170 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17171 {
17172 PyThreadState* __tstate = wxPyBeginAllowThreads();
17173 result = (wxBMPHandler *)new wxBMPHandler();
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17185 PyObject *obj;
17186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17187 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17188 return SWIG_Py_Void();
17189 }
17190
17191 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17192 return SWIG_Python_InitShadowInstance(args);
17193 }
17194
17195 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17196 PyObject *resultobj = 0;
17197 wxICOHandler *result = 0 ;
17198
17199 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17200 {
17201 PyThreadState* __tstate = wxPyBeginAllowThreads();
17202 result = (wxICOHandler *)new wxICOHandler();
17203 wxPyEndAllowThreads(__tstate);
17204 if (PyErr_Occurred()) SWIG_fail;
17205 }
17206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17207 return resultobj;
17208 fail:
17209 return NULL;
17210 }
17211
17212
17213 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17214 PyObject *obj;
17215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17216 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17217 return SWIG_Py_Void();
17218 }
17219
17220 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17221 return SWIG_Python_InitShadowInstance(args);
17222 }
17223
17224 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17225 PyObject *resultobj = 0;
17226 wxCURHandler *result = 0 ;
17227
17228 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17229 {
17230 PyThreadState* __tstate = wxPyBeginAllowThreads();
17231 result = (wxCURHandler *)new wxCURHandler();
17232 wxPyEndAllowThreads(__tstate);
17233 if (PyErr_Occurred()) SWIG_fail;
17234 }
17235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17236 return resultobj;
17237 fail:
17238 return NULL;
17239 }
17240
17241
17242 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17243 PyObject *obj;
17244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17245 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17246 return SWIG_Py_Void();
17247 }
17248
17249 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17250 return SWIG_Python_InitShadowInstance(args);
17251 }
17252
17253 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17254 PyObject *resultobj = 0;
17255 wxANIHandler *result = 0 ;
17256
17257 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17258 {
17259 PyThreadState* __tstate = wxPyBeginAllowThreads();
17260 result = (wxANIHandler *)new wxANIHandler();
17261 wxPyEndAllowThreads(__tstate);
17262 if (PyErr_Occurred()) SWIG_fail;
17263 }
17264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17265 return resultobj;
17266 fail:
17267 return NULL;
17268 }
17269
17270
17271 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17272 PyObject *obj;
17273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17274 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17275 return SWIG_Py_Void();
17276 }
17277
17278 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17279 return SWIG_Python_InitShadowInstance(args);
17280 }
17281
17282 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17283 PyObject *resultobj = 0;
17284 wxPNGHandler *result = 0 ;
17285
17286 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17287 {
17288 PyThreadState* __tstate = wxPyBeginAllowThreads();
17289 result = (wxPNGHandler *)new wxPNGHandler();
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17294 return resultobj;
17295 fail:
17296 return NULL;
17297 }
17298
17299
17300 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301 PyObject *obj;
17302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17303 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17304 return SWIG_Py_Void();
17305 }
17306
17307 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17308 return SWIG_Python_InitShadowInstance(args);
17309 }
17310
17311 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17312 PyObject *resultobj = 0;
17313 wxGIFHandler *result = 0 ;
17314
17315 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17316 {
17317 PyThreadState* __tstate = wxPyBeginAllowThreads();
17318 result = (wxGIFHandler *)new wxGIFHandler();
17319 wxPyEndAllowThreads(__tstate);
17320 if (PyErr_Occurred()) SWIG_fail;
17321 }
17322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17323 return resultobj;
17324 fail:
17325 return NULL;
17326 }
17327
17328
17329 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17330 PyObject *obj;
17331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17332 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17333 return SWIG_Py_Void();
17334 }
17335
17336 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17337 return SWIG_Python_InitShadowInstance(args);
17338 }
17339
17340 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17341 PyObject *resultobj = 0;
17342 wxPCXHandler *result = 0 ;
17343
17344 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17345 {
17346 PyThreadState* __tstate = wxPyBeginAllowThreads();
17347 result = (wxPCXHandler *)new wxPCXHandler();
17348 wxPyEndAllowThreads(__tstate);
17349 if (PyErr_Occurred()) SWIG_fail;
17350 }
17351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17352 return resultobj;
17353 fail:
17354 return NULL;
17355 }
17356
17357
17358 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 PyObject *obj;
17360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17361 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17362 return SWIG_Py_Void();
17363 }
17364
17365 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17366 return SWIG_Python_InitShadowInstance(args);
17367 }
17368
17369 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17370 PyObject *resultobj = 0;
17371 wxJPEGHandler *result = 0 ;
17372
17373 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = (wxJPEGHandler *)new wxJPEGHandler();
17377 wxPyEndAllowThreads(__tstate);
17378 if (PyErr_Occurred()) SWIG_fail;
17379 }
17380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17381 return resultobj;
17382 fail:
17383 return NULL;
17384 }
17385
17386
17387 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 PyObject *obj;
17389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17390 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17391 return SWIG_Py_Void();
17392 }
17393
17394 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17395 return SWIG_Python_InitShadowInstance(args);
17396 }
17397
17398 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17399 PyObject *resultobj = 0;
17400 wxPNMHandler *result = 0 ;
17401
17402 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17403 {
17404 PyThreadState* __tstate = wxPyBeginAllowThreads();
17405 result = (wxPNMHandler *)new wxPNMHandler();
17406 wxPyEndAllowThreads(__tstate);
17407 if (PyErr_Occurred()) SWIG_fail;
17408 }
17409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17410 return resultobj;
17411 fail:
17412 return NULL;
17413 }
17414
17415
17416 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17417 PyObject *obj;
17418 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17419 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17420 return SWIG_Py_Void();
17421 }
17422
17423 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17424 return SWIG_Python_InitShadowInstance(args);
17425 }
17426
17427 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 PyObject *resultobj = 0;
17429 wxXPMHandler *result = 0 ;
17430
17431 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17432 {
17433 PyThreadState* __tstate = wxPyBeginAllowThreads();
17434 result = (wxXPMHandler *)new wxXPMHandler();
17435 wxPyEndAllowThreads(__tstate);
17436 if (PyErr_Occurred()) SWIG_fail;
17437 }
17438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17439 return resultobj;
17440 fail:
17441 return NULL;
17442 }
17443
17444
17445 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17446 PyObject *obj;
17447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17448 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17449 return SWIG_Py_Void();
17450 }
17451
17452 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17453 return SWIG_Python_InitShadowInstance(args);
17454 }
17455
17456 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17457 PyObject *resultobj = 0;
17458 wxTIFFHandler *result = 0 ;
17459
17460 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17461 {
17462 PyThreadState* __tstate = wxPyBeginAllowThreads();
17463 result = (wxTIFFHandler *)new wxTIFFHandler();
17464 wxPyEndAllowThreads(__tstate);
17465 if (PyErr_Occurred()) SWIG_fail;
17466 }
17467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17468 return resultobj;
17469 fail:
17470 return NULL;
17471 }
17472
17473
17474 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *obj;
17476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17477 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17478 return SWIG_Py_Void();
17479 }
17480
17481 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17482 return SWIG_Python_InitShadowInstance(args);
17483 }
17484
17485 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj = 0;
17487 wxImage *arg1 = 0 ;
17488 wxImage *arg2 = 0 ;
17489 int arg3 = (int) 236 ;
17490 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17491 bool result;
17492 void *argp1 = 0 ;
17493 int res1 = 0 ;
17494 void *argp2 = 0 ;
17495 int res2 = 0 ;
17496 int val3 ;
17497 int ecode3 = 0 ;
17498 int val4 ;
17499 int ecode4 = 0 ;
17500 PyObject * obj0 = 0 ;
17501 PyObject * obj1 = 0 ;
17502 PyObject * obj2 = 0 ;
17503 PyObject * obj3 = 0 ;
17504 char * kwnames[] = {
17505 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17506 };
17507
17508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17509 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17510 if (!SWIG_IsOK(res1)) {
17511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17512 }
17513 if (!argp1) {
17514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17515 }
17516 arg1 = reinterpret_cast< wxImage * >(argp1);
17517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17518 if (!SWIG_IsOK(res2)) {
17519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17520 }
17521 if (!argp2) {
17522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17523 }
17524 arg2 = reinterpret_cast< wxImage * >(argp2);
17525 if (obj2) {
17526 ecode3 = SWIG_AsVal_int(obj2, &val3);
17527 if (!SWIG_IsOK(ecode3)) {
17528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17529 }
17530 arg3 = static_cast< int >(val3);
17531 }
17532 if (obj3) {
17533 ecode4 = SWIG_AsVal_int(obj3, &val4);
17534 if (!SWIG_IsOK(ecode4)) {
17535 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17536 }
17537 arg4 = static_cast< int >(val4);
17538 }
17539 {
17540 PyThreadState* __tstate = wxPyBeginAllowThreads();
17541 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 {
17546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17547 }
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *obj;
17556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17557 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17558 return SWIG_Py_Void();
17559 }
17560
17561 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17562 PyObject *resultobj = 0;
17563 wxEvtHandler *result = 0 ;
17564
17565 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (wxEvtHandler *)new wxEvtHandler();
17569 wxPyEndAllowThreads(__tstate);
17570 if (PyErr_Occurred()) SWIG_fail;
17571 }
17572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17573 return resultobj;
17574 fail:
17575 return NULL;
17576 }
17577
17578
17579 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 PyObject *resultobj = 0;
17581 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17582 wxEvtHandler *result = 0 ;
17583 void *argp1 = 0 ;
17584 int res1 = 0 ;
17585 PyObject *swig_obj[1] ;
17586
17587 if (!args) SWIG_fail;
17588 swig_obj[0] = args;
17589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17590 if (!SWIG_IsOK(res1)) {
17591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17592 }
17593 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17597 wxPyEndAllowThreads(__tstate);
17598 if (PyErr_Occurred()) SWIG_fail;
17599 }
17600 {
17601 resultobj = wxPyMake_wxObject(result, 0);
17602 }
17603 return resultobj;
17604 fail:
17605 return NULL;
17606 }
17607
17608
17609 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17610 PyObject *resultobj = 0;
17611 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17612 wxEvtHandler *result = 0 ;
17613 void *argp1 = 0 ;
17614 int res1 = 0 ;
17615 PyObject *swig_obj[1] ;
17616
17617 if (!args) SWIG_fail;
17618 swig_obj[0] = args;
17619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17620 if (!SWIG_IsOK(res1)) {
17621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17622 }
17623 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 {
17631 resultobj = wxPyMake_wxObject(result, 0);
17632 }
17633 return resultobj;
17634 fail:
17635 return NULL;
17636 }
17637
17638
17639 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17640 PyObject *resultobj = 0;
17641 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17642 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17643 void *argp1 = 0 ;
17644 int res1 = 0 ;
17645 void *argp2 = 0 ;
17646 int res2 = 0 ;
17647 PyObject * obj0 = 0 ;
17648 PyObject * obj1 = 0 ;
17649 char * kwnames[] = {
17650 (char *) "self",(char *) "handler", NULL
17651 };
17652
17653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17655 if (!SWIG_IsOK(res1)) {
17656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17657 }
17658 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17659 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17660 if (!SWIG_IsOK(res2)) {
17661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17662 }
17663 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17664 {
17665 PyThreadState* __tstate = wxPyBeginAllowThreads();
17666 (arg1)->SetNextHandler(arg2);
17667 wxPyEndAllowThreads(__tstate);
17668 if (PyErr_Occurred()) SWIG_fail;
17669 }
17670 resultobj = SWIG_Py_Void();
17671 return resultobj;
17672 fail:
17673 return NULL;
17674 }
17675
17676
17677 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj = 0;
17679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17680 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17681 void *argp1 = 0 ;
17682 int res1 = 0 ;
17683 void *argp2 = 0 ;
17684 int res2 = 0 ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 char * kwnames[] = {
17688 (char *) "self",(char *) "handler", NULL
17689 };
17690
17691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17693 if (!SWIG_IsOK(res1)) {
17694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17695 }
17696 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17698 if (!SWIG_IsOK(res2)) {
17699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17700 }
17701 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 (arg1)->SetPreviousHandler(arg2);
17705 wxPyEndAllowThreads(__tstate);
17706 if (PyErr_Occurred()) SWIG_fail;
17707 }
17708 resultobj = SWIG_Py_Void();
17709 return resultobj;
17710 fail:
17711 return NULL;
17712 }
17713
17714
17715 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17716 PyObject *resultobj = 0;
17717 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17718 bool result;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 PyObject *swig_obj[1] ;
17722
17723 if (!args) SWIG_fail;
17724 swig_obj[0] = args;
17725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17726 if (!SWIG_IsOK(res1)) {
17727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17728 }
17729 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17730 {
17731 PyThreadState* __tstate = wxPyBeginAllowThreads();
17732 result = (bool)(arg1)->GetEvtHandlerEnabled();
17733 wxPyEndAllowThreads(__tstate);
17734 if (PyErr_Occurred()) SWIG_fail;
17735 }
17736 {
17737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17738 }
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj = 0;
17747 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17748 bool arg2 ;
17749 void *argp1 = 0 ;
17750 int res1 = 0 ;
17751 bool val2 ;
17752 int ecode2 = 0 ;
17753 PyObject * obj0 = 0 ;
17754 PyObject * obj1 = 0 ;
17755 char * kwnames[] = {
17756 (char *) "self",(char *) "enabled", NULL
17757 };
17758
17759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17761 if (!SWIG_IsOK(res1)) {
17762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17763 }
17764 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17765 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17766 if (!SWIG_IsOK(ecode2)) {
17767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17768 }
17769 arg2 = static_cast< bool >(val2);
17770 {
17771 PyThreadState* __tstate = wxPyBeginAllowThreads();
17772 (arg1)->SetEvtHandlerEnabled(arg2);
17773 wxPyEndAllowThreads(__tstate);
17774 if (PyErr_Occurred()) SWIG_fail;
17775 }
17776 resultobj = SWIG_Py_Void();
17777 return resultobj;
17778 fail:
17779 return NULL;
17780 }
17781
17782
17783 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17784 PyObject *resultobj = 0;
17785 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17786 wxEvent *arg2 = 0 ;
17787 bool result;
17788 void *argp1 = 0 ;
17789 int res1 = 0 ;
17790 void *argp2 = 0 ;
17791 int res2 = 0 ;
17792 PyObject * obj0 = 0 ;
17793 PyObject * obj1 = 0 ;
17794 char * kwnames[] = {
17795 (char *) "self",(char *) "event", NULL
17796 };
17797
17798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17800 if (!SWIG_IsOK(res1)) {
17801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17802 }
17803 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17804 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17805 if (!SWIG_IsOK(res2)) {
17806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17807 }
17808 if (!argp2) {
17809 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17810 }
17811 arg2 = reinterpret_cast< wxEvent * >(argp2);
17812 {
17813 PyThreadState* __tstate = wxPyBeginAllowThreads();
17814 result = (bool)(arg1)->ProcessEvent(*arg2);
17815 wxPyEndAllowThreads(__tstate);
17816 if (PyErr_Occurred()) SWIG_fail;
17817 }
17818 {
17819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17820 }
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj = 0;
17829 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17830 wxEvent *arg2 = 0 ;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 void *argp2 = 0 ;
17834 int res2 = 0 ;
17835 PyObject * obj0 = 0 ;
17836 PyObject * obj1 = 0 ;
17837 char * kwnames[] = {
17838 (char *) "self",(char *) "event", NULL
17839 };
17840
17841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17845 }
17846 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17848 if (!SWIG_IsOK(res2)) {
17849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17850 }
17851 if (!argp2) {
17852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17853 }
17854 arg2 = reinterpret_cast< wxEvent * >(argp2);
17855 {
17856 PyThreadState* __tstate = wxPyBeginAllowThreads();
17857 (arg1)->AddPendingEvent(*arg2);
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 resultobj = SWIG_Py_Void();
17862 return resultobj;
17863 fail:
17864 return NULL;
17865 }
17866
17867
17868 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17869 PyObject *resultobj = 0;
17870 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17871 void *argp1 = 0 ;
17872 int res1 = 0 ;
17873 PyObject *swig_obj[1] ;
17874
17875 if (!args) SWIG_fail;
17876 swig_obj[0] = args;
17877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17878 if (!SWIG_IsOK(res1)) {
17879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17880 }
17881 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 (arg1)->ProcessPendingEvents();
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 resultobj = SWIG_Py_Void();
17889 return resultobj;
17890 fail:
17891 return NULL;
17892 }
17893
17894
17895 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17896 PyObject *resultobj = 0;
17897 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17898 int arg2 ;
17899 int arg3 ;
17900 int arg4 ;
17901 PyObject *arg5 = (PyObject *) 0 ;
17902 void *argp1 = 0 ;
17903 int res1 = 0 ;
17904 int val2 ;
17905 int ecode2 = 0 ;
17906 int val3 ;
17907 int ecode3 = 0 ;
17908 int val4 ;
17909 int ecode4 = 0 ;
17910 PyObject * obj0 = 0 ;
17911 PyObject * obj1 = 0 ;
17912 PyObject * obj2 = 0 ;
17913 PyObject * obj3 = 0 ;
17914 PyObject * obj4 = 0 ;
17915 char * kwnames[] = {
17916 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17917 };
17918
17919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17921 if (!SWIG_IsOK(res1)) {
17922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17923 }
17924 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17925 ecode2 = SWIG_AsVal_int(obj1, &val2);
17926 if (!SWIG_IsOK(ecode2)) {
17927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17928 }
17929 arg2 = static_cast< int >(val2);
17930 ecode3 = SWIG_AsVal_int(obj2, &val3);
17931 if (!SWIG_IsOK(ecode3)) {
17932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17933 }
17934 arg3 = static_cast< int >(val3);
17935 ecode4 = SWIG_AsVal_int(obj3, &val4);
17936 if (!SWIG_IsOK(ecode4)) {
17937 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17938 }
17939 arg4 = static_cast< int >(val4);
17940 arg5 = obj4;
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 resultobj = SWIG_Py_Void();
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj = 0;
17956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17957 int arg2 ;
17958 int arg3 = (int) -1 ;
17959 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17960 bool result;
17961 void *argp1 = 0 ;
17962 int res1 = 0 ;
17963 int val2 ;
17964 int ecode2 = 0 ;
17965 int val3 ;
17966 int ecode3 = 0 ;
17967 int val4 ;
17968 int ecode4 = 0 ;
17969 PyObject * obj0 = 0 ;
17970 PyObject * obj1 = 0 ;
17971 PyObject * obj2 = 0 ;
17972 PyObject * obj3 = 0 ;
17973 char * kwnames[] = {
17974 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17975 };
17976
17977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17981 }
17982 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17983 ecode2 = SWIG_AsVal_int(obj1, &val2);
17984 if (!SWIG_IsOK(ecode2)) {
17985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17986 }
17987 arg2 = static_cast< int >(val2);
17988 if (obj2) {
17989 ecode3 = SWIG_AsVal_int(obj2, &val3);
17990 if (!SWIG_IsOK(ecode3)) {
17991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17992 }
17993 arg3 = static_cast< int >(val3);
17994 }
17995 if (obj3) {
17996 ecode4 = SWIG_AsVal_int(obj3, &val4);
17997 if (!SWIG_IsOK(ecode4)) {
17998 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17999 }
18000 arg4 = static_cast< wxEventType >(val4);
18001 }
18002 {
18003 PyThreadState* __tstate = wxPyBeginAllowThreads();
18004 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 {
18009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18010 }
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18018 PyObject *resultobj = 0;
18019 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18020 PyObject *arg2 = (PyObject *) 0 ;
18021 bool arg3 = (bool) true ;
18022 void *argp1 = 0 ;
18023 int res1 = 0 ;
18024 bool val3 ;
18025 int ecode3 = 0 ;
18026 PyObject * obj0 = 0 ;
18027 PyObject * obj1 = 0 ;
18028 PyObject * obj2 = 0 ;
18029 char * kwnames[] = {
18030 (char *) "self",(char *) "_self",(char *) "incref", NULL
18031 };
18032
18033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18035 if (!SWIG_IsOK(res1)) {
18036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18037 }
18038 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18039 arg2 = obj1;
18040 if (obj2) {
18041 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18042 if (!SWIG_IsOK(ecode3)) {
18043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18044 }
18045 arg3 = static_cast< bool >(val3);
18046 }
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 resultobj = SWIG_Py_Void();
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 PyObject *obj;
18062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18063 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18064 return SWIG_Py_Void();
18065 }
18066
18067 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18068 return SWIG_Python_InitShadowInstance(args);
18069 }
18070
18071 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18072 PyObject *resultobj = 0;
18073 wxEventType result;
18074
18075 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18076 {
18077 PyThreadState* __tstate = wxPyBeginAllowThreads();
18078 result = (wxEventType)wxNewEventType();
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 resultobj = SWIG_From_int(static_cast< int >(result));
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 PyObject *resultobj = 0;
18091 wxEvent *arg1 = (wxEvent *) 0 ;
18092 void *argp1 = 0 ;
18093 int res1 = 0 ;
18094 PyObject *swig_obj[1] ;
18095
18096 if (!args) SWIG_fail;
18097 swig_obj[0] = args;
18098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18101 }
18102 arg1 = reinterpret_cast< wxEvent * >(argp1);
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 delete arg1;
18106
18107 wxPyEndAllowThreads(__tstate);
18108 if (PyErr_Occurred()) SWIG_fail;
18109 }
18110 resultobj = SWIG_Py_Void();
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj = 0;
18119 wxEvent *arg1 = (wxEvent *) 0 ;
18120 wxEventType arg2 ;
18121 void *argp1 = 0 ;
18122 int res1 = 0 ;
18123 int val2 ;
18124 int ecode2 = 0 ;
18125 PyObject * obj0 = 0 ;
18126 PyObject * obj1 = 0 ;
18127 char * kwnames[] = {
18128 (char *) "self",(char *) "typ", NULL
18129 };
18130
18131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18133 if (!SWIG_IsOK(res1)) {
18134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18135 }
18136 arg1 = reinterpret_cast< wxEvent * >(argp1);
18137 ecode2 = SWIG_AsVal_int(obj1, &val2);
18138 if (!SWIG_IsOK(ecode2)) {
18139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18140 }
18141 arg2 = static_cast< wxEventType >(val2);
18142 {
18143 PyThreadState* __tstate = wxPyBeginAllowThreads();
18144 (arg1)->SetEventType(arg2);
18145 wxPyEndAllowThreads(__tstate);
18146 if (PyErr_Occurred()) SWIG_fail;
18147 }
18148 resultobj = SWIG_Py_Void();
18149 return resultobj;
18150 fail:
18151 return NULL;
18152 }
18153
18154
18155 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18156 PyObject *resultobj = 0;
18157 wxEvent *arg1 = (wxEvent *) 0 ;
18158 wxEventType result;
18159 void *argp1 = 0 ;
18160 int res1 = 0 ;
18161 PyObject *swig_obj[1] ;
18162
18163 if (!args) SWIG_fail;
18164 swig_obj[0] = args;
18165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18166 if (!SWIG_IsOK(res1)) {
18167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18168 }
18169 arg1 = reinterpret_cast< wxEvent * >(argp1);
18170 {
18171 PyThreadState* __tstate = wxPyBeginAllowThreads();
18172 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18173 wxPyEndAllowThreads(__tstate);
18174 if (PyErr_Occurred()) SWIG_fail;
18175 }
18176 resultobj = SWIG_From_int(static_cast< int >(result));
18177 return resultobj;
18178 fail:
18179 return NULL;
18180 }
18181
18182
18183 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18184 PyObject *resultobj = 0;
18185 wxEvent *arg1 = (wxEvent *) 0 ;
18186 wxObject *result = 0 ;
18187 void *argp1 = 0 ;
18188 int res1 = 0 ;
18189 PyObject *swig_obj[1] ;
18190
18191 if (!args) SWIG_fail;
18192 swig_obj[0] = args;
18193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18194 if (!SWIG_IsOK(res1)) {
18195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18196 }
18197 arg1 = reinterpret_cast< wxEvent * >(argp1);
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 {
18205 resultobj = wxPyMake_wxObject(result, (bool)0);
18206 }
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj = 0;
18215 wxEvent *arg1 = (wxEvent *) 0 ;
18216 wxObject *arg2 = (wxObject *) 0 ;
18217 void *argp1 = 0 ;
18218 int res1 = 0 ;
18219 void *argp2 = 0 ;
18220 int res2 = 0 ;
18221 PyObject * obj0 = 0 ;
18222 PyObject * obj1 = 0 ;
18223 char * kwnames[] = {
18224 (char *) "self",(char *) "obj", NULL
18225 };
18226
18227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18231 }
18232 arg1 = reinterpret_cast< wxEvent * >(argp1);
18233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18234 if (!SWIG_IsOK(res2)) {
18235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18236 }
18237 arg2 = reinterpret_cast< wxObject * >(argp2);
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 (arg1)->SetEventObject(arg2);
18241 wxPyEndAllowThreads(__tstate);
18242 if (PyErr_Occurred()) SWIG_fail;
18243 }
18244 resultobj = SWIG_Py_Void();
18245 return resultobj;
18246 fail:
18247 return NULL;
18248 }
18249
18250
18251 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18252 PyObject *resultobj = 0;
18253 wxEvent *arg1 = (wxEvent *) 0 ;
18254 long result;
18255 void *argp1 = 0 ;
18256 int res1 = 0 ;
18257 PyObject *swig_obj[1] ;
18258
18259 if (!args) SWIG_fail;
18260 swig_obj[0] = args;
18261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18262 if (!SWIG_IsOK(res1)) {
18263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18264 }
18265 arg1 = reinterpret_cast< wxEvent * >(argp1);
18266 {
18267 PyThreadState* __tstate = wxPyBeginAllowThreads();
18268 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18269 wxPyEndAllowThreads(__tstate);
18270 if (PyErr_Occurred()) SWIG_fail;
18271 }
18272 resultobj = SWIG_From_long(static_cast< long >(result));
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj = 0;
18281 wxEvent *arg1 = (wxEvent *) 0 ;
18282 long arg2 = (long) 0 ;
18283 void *argp1 = 0 ;
18284 int res1 = 0 ;
18285 long val2 ;
18286 int ecode2 = 0 ;
18287 PyObject * obj0 = 0 ;
18288 PyObject * obj1 = 0 ;
18289 char * kwnames[] = {
18290 (char *) "self",(char *) "ts", NULL
18291 };
18292
18293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18295 if (!SWIG_IsOK(res1)) {
18296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18297 }
18298 arg1 = reinterpret_cast< wxEvent * >(argp1);
18299 if (obj1) {
18300 ecode2 = SWIG_AsVal_long(obj1, &val2);
18301 if (!SWIG_IsOK(ecode2)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18303 }
18304 arg2 = static_cast< long >(val2);
18305 }
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 (arg1)->SetTimestamp(arg2);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_Py_Void();
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *resultobj = 0;
18321 wxEvent *arg1 = (wxEvent *) 0 ;
18322 int result;
18323 void *argp1 = 0 ;
18324 int res1 = 0 ;
18325 PyObject *swig_obj[1] ;
18326
18327 if (!args) SWIG_fail;
18328 swig_obj[0] = args;
18329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18330 if (!SWIG_IsOK(res1)) {
18331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18332 }
18333 arg1 = reinterpret_cast< wxEvent * >(argp1);
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = (int)((wxEvent const *)arg1)->GetId();
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_From_int(static_cast< int >(result));
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18348 PyObject *resultobj = 0;
18349 wxEvent *arg1 = (wxEvent *) 0 ;
18350 int arg2 ;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 int val2 ;
18354 int ecode2 = 0 ;
18355 PyObject * obj0 = 0 ;
18356 PyObject * obj1 = 0 ;
18357 char * kwnames[] = {
18358 (char *) "self",(char *) "Id", NULL
18359 };
18360
18361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18363 if (!SWIG_IsOK(res1)) {
18364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18365 }
18366 arg1 = reinterpret_cast< wxEvent * >(argp1);
18367 ecode2 = SWIG_AsVal_int(obj1, &val2);
18368 if (!SWIG_IsOK(ecode2)) {
18369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18370 }
18371 arg2 = static_cast< int >(val2);
18372 {
18373 PyThreadState* __tstate = wxPyBeginAllowThreads();
18374 (arg1)->SetId(arg2);
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 resultobj = SWIG_Py_Void();
18379 return resultobj;
18380 fail:
18381 return NULL;
18382 }
18383
18384
18385 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18386 PyObject *resultobj = 0;
18387 wxEvent *arg1 = (wxEvent *) 0 ;
18388 bool result;
18389 void *argp1 = 0 ;
18390 int res1 = 0 ;
18391 PyObject *swig_obj[1] ;
18392
18393 if (!args) SWIG_fail;
18394 swig_obj[0] = args;
18395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18398 }
18399 arg1 = reinterpret_cast< wxEvent * >(argp1);
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 {
18407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18408 }
18409 return resultobj;
18410 fail:
18411 return NULL;
18412 }
18413
18414
18415 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18416 PyObject *resultobj = 0;
18417 wxEvent *arg1 = (wxEvent *) 0 ;
18418 bool arg2 = (bool) true ;
18419 void *argp1 = 0 ;
18420 int res1 = 0 ;
18421 bool val2 ;
18422 int ecode2 = 0 ;
18423 PyObject * obj0 = 0 ;
18424 PyObject * obj1 = 0 ;
18425 char * kwnames[] = {
18426 (char *) "self",(char *) "skip", NULL
18427 };
18428
18429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvent * >(argp1);
18435 if (obj1) {
18436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18437 if (!SWIG_IsOK(ecode2)) {
18438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18439 }
18440 arg2 = static_cast< bool >(val2);
18441 }
18442 {
18443 PyThreadState* __tstate = wxPyBeginAllowThreads();
18444 (arg1)->Skip(arg2);
18445 wxPyEndAllowThreads(__tstate);
18446 if (PyErr_Occurred()) SWIG_fail;
18447 }
18448 resultobj = SWIG_Py_Void();
18449 return resultobj;
18450 fail:
18451 return NULL;
18452 }
18453
18454
18455 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18456 PyObject *resultobj = 0;
18457 wxEvent *arg1 = (wxEvent *) 0 ;
18458 bool result;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 PyObject *swig_obj[1] ;
18462
18463 if (!args) SWIG_fail;
18464 swig_obj[0] = args;
18465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18468 }
18469 arg1 = reinterpret_cast< wxEvent * >(argp1);
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18486 PyObject *resultobj = 0;
18487 wxEvent *arg1 = (wxEvent *) 0 ;
18488 bool result;
18489 void *argp1 = 0 ;
18490 int res1 = 0 ;
18491 PyObject *swig_obj[1] ;
18492
18493 if (!args) SWIG_fail;
18494 swig_obj[0] = args;
18495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18496 if (!SWIG_IsOK(res1)) {
18497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18498 }
18499 arg1 = reinterpret_cast< wxEvent * >(argp1);
18500 {
18501 PyThreadState* __tstate = wxPyBeginAllowThreads();
18502 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 {
18507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18508 }
18509 return resultobj;
18510 fail:
18511 return NULL;
18512 }
18513
18514
18515 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18516 PyObject *resultobj = 0;
18517 wxEvent *arg1 = (wxEvent *) 0 ;
18518 int result;
18519 void *argp1 = 0 ;
18520 int res1 = 0 ;
18521 PyObject *swig_obj[1] ;
18522
18523 if (!args) SWIG_fail;
18524 swig_obj[0] = args;
18525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18526 if (!SWIG_IsOK(res1)) {
18527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18528 }
18529 arg1 = reinterpret_cast< wxEvent * >(argp1);
18530 {
18531 PyThreadState* __tstate = wxPyBeginAllowThreads();
18532 result = (int)(arg1)->StopPropagation();
18533 wxPyEndAllowThreads(__tstate);
18534 if (PyErr_Occurred()) SWIG_fail;
18535 }
18536 resultobj = SWIG_From_int(static_cast< int >(result));
18537 return resultobj;
18538 fail:
18539 return NULL;
18540 }
18541
18542
18543 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18544 PyObject *resultobj = 0;
18545 wxEvent *arg1 = (wxEvent *) 0 ;
18546 int arg2 ;
18547 void *argp1 = 0 ;
18548 int res1 = 0 ;
18549 int val2 ;
18550 int ecode2 = 0 ;
18551 PyObject * obj0 = 0 ;
18552 PyObject * obj1 = 0 ;
18553 char * kwnames[] = {
18554 (char *) "self",(char *) "propagationLevel", NULL
18555 };
18556
18557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18559 if (!SWIG_IsOK(res1)) {
18560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18561 }
18562 arg1 = reinterpret_cast< wxEvent * >(argp1);
18563 ecode2 = SWIG_AsVal_int(obj1, &val2);
18564 if (!SWIG_IsOK(ecode2)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18566 }
18567 arg2 = static_cast< int >(val2);
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 (arg1)->ResumePropagation(arg2);
18571 wxPyEndAllowThreads(__tstate);
18572 if (PyErr_Occurred()) SWIG_fail;
18573 }
18574 resultobj = SWIG_Py_Void();
18575 return resultobj;
18576 fail:
18577 return NULL;
18578 }
18579
18580
18581 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18582 PyObject *resultobj = 0;
18583 wxEvent *arg1 = (wxEvent *) 0 ;
18584 wxEvent *result = 0 ;
18585 void *argp1 = 0 ;
18586 int res1 = 0 ;
18587 PyObject *swig_obj[1] ;
18588
18589 if (!args) SWIG_fail;
18590 swig_obj[0] = args;
18591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18592 if (!SWIG_IsOK(res1)) {
18593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18594 }
18595 arg1 = reinterpret_cast< wxEvent * >(argp1);
18596 {
18597 PyThreadState* __tstate = wxPyBeginAllowThreads();
18598 result = (wxEvent *)(arg1)->Clone();
18599 wxPyEndAllowThreads(__tstate);
18600 if (PyErr_Occurred()) SWIG_fail;
18601 }
18602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18610 PyObject *obj;
18611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18612 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18613 return SWIG_Py_Void();
18614 }
18615
18616 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18617 PyObject *resultobj = 0;
18618 wxEvent *arg1 = 0 ;
18619 wxPropagationDisabler *result = 0 ;
18620 void *argp1 = 0 ;
18621 int res1 = 0 ;
18622 PyObject * obj0 = 0 ;
18623 char * kwnames[] = {
18624 (char *) "event", NULL
18625 };
18626
18627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18628 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18629 if (!SWIG_IsOK(res1)) {
18630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18631 }
18632 if (!argp1) {
18633 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18634 }
18635 arg1 = reinterpret_cast< wxEvent * >(argp1);
18636 {
18637 PyThreadState* __tstate = wxPyBeginAllowThreads();
18638 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18639 wxPyEndAllowThreads(__tstate);
18640 if (PyErr_Occurred()) SWIG_fail;
18641 }
18642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18643 return resultobj;
18644 fail:
18645 return NULL;
18646 }
18647
18648
18649 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18650 PyObject *resultobj = 0;
18651 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18652 void *argp1 = 0 ;
18653 int res1 = 0 ;
18654 PyObject *swig_obj[1] ;
18655
18656 if (!args) SWIG_fail;
18657 swig_obj[0] = args;
18658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18659 if (!SWIG_IsOK(res1)) {
18660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18661 }
18662 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18663 {
18664 PyThreadState* __tstate = wxPyBeginAllowThreads();
18665 delete arg1;
18666
18667 wxPyEndAllowThreads(__tstate);
18668 if (PyErr_Occurred()) SWIG_fail;
18669 }
18670 resultobj = SWIG_Py_Void();
18671 return resultobj;
18672 fail:
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18678 PyObject *obj;
18679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18680 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18681 return SWIG_Py_Void();
18682 }
18683
18684 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18685 return SWIG_Python_InitShadowInstance(args);
18686 }
18687
18688 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18689 PyObject *resultobj = 0;
18690 wxEvent *arg1 = 0 ;
18691 wxPropagateOnce *result = 0 ;
18692 void *argp1 = 0 ;
18693 int res1 = 0 ;
18694 PyObject * obj0 = 0 ;
18695 char * kwnames[] = {
18696 (char *) "event", NULL
18697 };
18698
18699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18701 if (!SWIG_IsOK(res1)) {
18702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18703 }
18704 if (!argp1) {
18705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18706 }
18707 arg1 = reinterpret_cast< wxEvent * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18722 PyObject *resultobj = 0;
18723 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18724 void *argp1 = 0 ;
18725 int res1 = 0 ;
18726 PyObject *swig_obj[1] ;
18727
18728 if (!args) SWIG_fail;
18729 swig_obj[0] = args;
18730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18731 if (!SWIG_IsOK(res1)) {
18732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18733 }
18734 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 delete arg1;
18738
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 resultobj = SWIG_Py_Void();
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18750 PyObject *obj;
18751 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18752 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18753 return SWIG_Py_Void();
18754 }
18755
18756 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18757 return SWIG_Python_InitShadowInstance(args);
18758 }
18759
18760 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18761 PyObject *resultobj = 0;
18762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18763 int arg2 = (int) 0 ;
18764 wxCommandEvent *result = 0 ;
18765 int val1 ;
18766 int ecode1 = 0 ;
18767 int val2 ;
18768 int ecode2 = 0 ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "commandType",(char *) "winid", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18776 if (obj0) {
18777 ecode1 = SWIG_AsVal_int(obj0, &val1);
18778 if (!SWIG_IsOK(ecode1)) {
18779 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18780 }
18781 arg1 = static_cast< wxEventType >(val1);
18782 }
18783 if (obj1) {
18784 ecode2 = SWIG_AsVal_int(obj1, &val2);
18785 if (!SWIG_IsOK(ecode2)) {
18786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18787 }
18788 arg2 = static_cast< int >(val2);
18789 }
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18793 wxPyEndAllowThreads(__tstate);
18794 if (PyErr_Occurred()) SWIG_fail;
18795 }
18796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18797 return resultobj;
18798 fail:
18799 return NULL;
18800 }
18801
18802
18803 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18804 PyObject *resultobj = 0;
18805 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18806 int result;
18807 void *argp1 = 0 ;
18808 int res1 = 0 ;
18809 PyObject *swig_obj[1] ;
18810
18811 if (!args) SWIG_fail;
18812 swig_obj[0] = args;
18813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18816 }
18817 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_From_int(static_cast< int >(result));
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj = 0;
18833 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18834 wxString *arg2 = 0 ;
18835 void *argp1 = 0 ;
18836 int res1 = 0 ;
18837 bool temp2 = false ;
18838 PyObject * obj0 = 0 ;
18839 PyObject * obj1 = 0 ;
18840 char * kwnames[] = {
18841 (char *) "self",(char *) "s", NULL
18842 };
18843
18844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18846 if (!SWIG_IsOK(res1)) {
18847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18848 }
18849 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18850 {
18851 arg2 = wxString_in_helper(obj1);
18852 if (arg2 == NULL) SWIG_fail;
18853 temp2 = true;
18854 }
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 (arg1)->SetString((wxString const &)*arg2);
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_Py_Void();
18862 {
18863 if (temp2)
18864 delete arg2;
18865 }
18866 return resultobj;
18867 fail:
18868 {
18869 if (temp2)
18870 delete arg2;
18871 }
18872 return NULL;
18873 }
18874
18875
18876 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18877 PyObject *resultobj = 0;
18878 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18879 wxString result;
18880 void *argp1 = 0 ;
18881 int res1 = 0 ;
18882 PyObject *swig_obj[1] ;
18883
18884 if (!args) SWIG_fail;
18885 swig_obj[0] = args;
18886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18887 if (!SWIG_IsOK(res1)) {
18888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18889 }
18890 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18891 {
18892 PyThreadState* __tstate = wxPyBeginAllowThreads();
18893 result = ((wxCommandEvent const *)arg1)->GetString();
18894 wxPyEndAllowThreads(__tstate);
18895 if (PyErr_Occurred()) SWIG_fail;
18896 }
18897 {
18898 #if wxUSE_UNICODE
18899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18900 #else
18901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18902 #endif
18903 }
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18911 PyObject *resultobj = 0;
18912 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18913 bool result;
18914 void *argp1 = 0 ;
18915 int res1 = 0 ;
18916 PyObject *swig_obj[1] ;
18917
18918 if (!args) SWIG_fail;
18919 swig_obj[0] = args;
18920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18921 if (!SWIG_IsOK(res1)) {
18922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18923 }
18924 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18925 {
18926 PyThreadState* __tstate = wxPyBeginAllowThreads();
18927 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18928 wxPyEndAllowThreads(__tstate);
18929 if (PyErr_Occurred()) SWIG_fail;
18930 }
18931 {
18932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18933 }
18934 return resultobj;
18935 fail:
18936 return NULL;
18937 }
18938
18939
18940 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18941 PyObject *resultobj = 0;
18942 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18943 bool result;
18944 void *argp1 = 0 ;
18945 int res1 = 0 ;
18946 PyObject *swig_obj[1] ;
18947
18948 if (!args) SWIG_fail;
18949 swig_obj[0] = args;
18950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18951 if (!SWIG_IsOK(res1)) {
18952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18953 }
18954 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18955 {
18956 PyThreadState* __tstate = wxPyBeginAllowThreads();
18957 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 {
18962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18963 }
18964 return resultobj;
18965 fail:
18966 return NULL;
18967 }
18968
18969
18970 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18971 PyObject *resultobj = 0;
18972 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18973 long arg2 ;
18974 void *argp1 = 0 ;
18975 int res1 = 0 ;
18976 long val2 ;
18977 int ecode2 = 0 ;
18978 PyObject * obj0 = 0 ;
18979 PyObject * obj1 = 0 ;
18980 char * kwnames[] = {
18981 (char *) "self",(char *) "extraLong", NULL
18982 };
18983
18984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18986 if (!SWIG_IsOK(res1)) {
18987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18988 }
18989 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18990 ecode2 = SWIG_AsVal_long(obj1, &val2);
18991 if (!SWIG_IsOK(ecode2)) {
18992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18993 }
18994 arg2 = static_cast< long >(val2);
18995 {
18996 PyThreadState* __tstate = wxPyBeginAllowThreads();
18997 (arg1)->SetExtraLong(arg2);
18998 wxPyEndAllowThreads(__tstate);
18999 if (PyErr_Occurred()) SWIG_fail;
19000 }
19001 resultobj = SWIG_Py_Void();
19002 return resultobj;
19003 fail:
19004 return NULL;
19005 }
19006
19007
19008 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19009 PyObject *resultobj = 0;
19010 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19011 long result;
19012 void *argp1 = 0 ;
19013 int res1 = 0 ;
19014 PyObject *swig_obj[1] ;
19015
19016 if (!args) SWIG_fail;
19017 swig_obj[0] = args;
19018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19019 if (!SWIG_IsOK(res1)) {
19020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19021 }
19022 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19023 {
19024 PyThreadState* __tstate = wxPyBeginAllowThreads();
19025 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19026 wxPyEndAllowThreads(__tstate);
19027 if (PyErr_Occurred()) SWIG_fail;
19028 }
19029 resultobj = SWIG_From_long(static_cast< long >(result));
19030 return resultobj;
19031 fail:
19032 return NULL;
19033 }
19034
19035
19036 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19037 PyObject *resultobj = 0;
19038 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19039 int arg2 ;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 int val2 ;
19043 int ecode2 = 0 ;
19044 PyObject * obj0 = 0 ;
19045 PyObject * obj1 = 0 ;
19046 char * kwnames[] = {
19047 (char *) "self",(char *) "i", NULL
19048 };
19049
19050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19052 if (!SWIG_IsOK(res1)) {
19053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19054 }
19055 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19056 ecode2 = SWIG_AsVal_int(obj1, &val2);
19057 if (!SWIG_IsOK(ecode2)) {
19058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19059 }
19060 arg2 = static_cast< int >(val2);
19061 {
19062 PyThreadState* __tstate = wxPyBeginAllowThreads();
19063 (arg1)->SetInt(arg2);
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_Py_Void();
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19075 PyObject *resultobj = 0;
19076 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19077 int result;
19078 void *argp1 = 0 ;
19079 int res1 = 0 ;
19080 PyObject *swig_obj[1] ;
19081
19082 if (!args) SWIG_fail;
19083 swig_obj[0] = args;
19084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19085 if (!SWIG_IsOK(res1)) {
19086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19087 }
19088 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19089 {
19090 PyThreadState* __tstate = wxPyBeginAllowThreads();
19091 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19092 wxPyEndAllowThreads(__tstate);
19093 if (PyErr_Occurred()) SWIG_fail;
19094 }
19095 resultobj = SWIG_From_int(static_cast< int >(result));
19096 return resultobj;
19097 fail:
19098 return NULL;
19099 }
19100
19101
19102 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19103 PyObject *resultobj = 0;
19104 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19105 PyObject *result = 0 ;
19106 void *argp1 = 0 ;
19107 int res1 = 0 ;
19108 PyObject *swig_obj[1] ;
19109
19110 if (!args) SWIG_fail;
19111 swig_obj[0] = args;
19112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19115 }
19116 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19120 wxPyEndAllowThreads(__tstate);
19121 if (PyErr_Occurred()) SWIG_fail;
19122 }
19123 resultobj = result;
19124 return resultobj;
19125 fail:
19126 return NULL;
19127 }
19128
19129
19130 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19131 PyObject *resultobj = 0;
19132 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19133 PyObject *arg2 = (PyObject *) 0 ;
19134 void *argp1 = 0 ;
19135 int res1 = 0 ;
19136 PyObject * obj0 = 0 ;
19137 PyObject * obj1 = 0 ;
19138 char * kwnames[] = {
19139 (char *) "self",(char *) "clientData", NULL
19140 };
19141
19142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19144 if (!SWIG_IsOK(res1)) {
19145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19146 }
19147 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19148 arg2 = obj1;
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 wxCommandEvent_SetClientData(arg1,arg2);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19163 PyObject *resultobj = 0;
19164 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19165 wxEvent *result = 0 ;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 PyObject *swig_obj[1] ;
19169
19170 if (!args) SWIG_fail;
19171 swig_obj[0] = args;
19172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19173 if (!SWIG_IsOK(res1)) {
19174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19175 }
19176 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19180 wxPyEndAllowThreads(__tstate);
19181 if (PyErr_Occurred()) SWIG_fail;
19182 }
19183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19191 PyObject *obj;
19192 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19193 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19194 return SWIG_Py_Void();
19195 }
19196
19197 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19198 return SWIG_Python_InitShadowInstance(args);
19199 }
19200
19201 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19202 PyObject *resultobj = 0;
19203 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19204 int arg2 = (int) 0 ;
19205 wxNotifyEvent *result = 0 ;
19206 int val1 ;
19207 int ecode1 = 0 ;
19208 int val2 ;
19209 int ecode2 = 0 ;
19210 PyObject * obj0 = 0 ;
19211 PyObject * obj1 = 0 ;
19212 char * kwnames[] = {
19213 (char *) "commandType",(char *) "winid", NULL
19214 };
19215
19216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19217 if (obj0) {
19218 ecode1 = SWIG_AsVal_int(obj0, &val1);
19219 if (!SWIG_IsOK(ecode1)) {
19220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19221 }
19222 arg1 = static_cast< wxEventType >(val1);
19223 }
19224 if (obj1) {
19225 ecode2 = SWIG_AsVal_int(obj1, &val2);
19226 if (!SWIG_IsOK(ecode2)) {
19227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19228 }
19229 arg2 = static_cast< int >(val2);
19230 }
19231 {
19232 PyThreadState* __tstate = wxPyBeginAllowThreads();
19233 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19234 wxPyEndAllowThreads(__tstate);
19235 if (PyErr_Occurred()) SWIG_fail;
19236 }
19237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19238 return resultobj;
19239 fail:
19240 return NULL;
19241 }
19242
19243
19244 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19245 PyObject *resultobj = 0;
19246 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19247 void *argp1 = 0 ;
19248 int res1 = 0 ;
19249 PyObject *swig_obj[1] ;
19250
19251 if (!args) SWIG_fail;
19252 swig_obj[0] = args;
19253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19254 if (!SWIG_IsOK(res1)) {
19255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19256 }
19257 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 (arg1)->Veto();
19261 wxPyEndAllowThreads(__tstate);
19262 if (PyErr_Occurred()) SWIG_fail;
19263 }
19264 resultobj = SWIG_Py_Void();
19265 return resultobj;
19266 fail:
19267 return NULL;
19268 }
19269
19270
19271 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19272 PyObject *resultobj = 0;
19273 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19274 void *argp1 = 0 ;
19275 int res1 = 0 ;
19276 PyObject *swig_obj[1] ;
19277
19278 if (!args) SWIG_fail;
19279 swig_obj[0] = args;
19280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19281 if (!SWIG_IsOK(res1)) {
19282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19283 }
19284 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 (arg1)->Allow();
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 resultobj = SWIG_Py_Void();
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19299 PyObject *resultobj = 0;
19300 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19301 bool result;
19302 void *argp1 = 0 ;
19303 int res1 = 0 ;
19304 PyObject *swig_obj[1] ;
19305
19306 if (!args) SWIG_fail;
19307 swig_obj[0] = args;
19308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19309 if (!SWIG_IsOK(res1)) {
19310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19311 }
19312 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19313 {
19314 PyThreadState* __tstate = wxPyBeginAllowThreads();
19315 result = (bool)(arg1)->IsAllowed();
19316 wxPyEndAllowThreads(__tstate);
19317 if (PyErr_Occurred()) SWIG_fail;
19318 }
19319 {
19320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19329 PyObject *obj;
19330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19331 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19332 return SWIG_Py_Void();
19333 }
19334
19335 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19336 return SWIG_Python_InitShadowInstance(args);
19337 }
19338
19339 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj = 0;
19341 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19342 int arg2 = (int) 0 ;
19343 int arg3 = (int) 0 ;
19344 int arg4 = (int) 0 ;
19345 wxScrollEvent *result = 0 ;
19346 int val1 ;
19347 int ecode1 = 0 ;
19348 int val2 ;
19349 int ecode2 = 0 ;
19350 int val3 ;
19351 int ecode3 = 0 ;
19352 int val4 ;
19353 int ecode4 = 0 ;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 PyObject * obj2 = 0 ;
19357 PyObject * obj3 = 0 ;
19358 char * kwnames[] = {
19359 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19360 };
19361
19362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19363 if (obj0) {
19364 ecode1 = SWIG_AsVal_int(obj0, &val1);
19365 if (!SWIG_IsOK(ecode1)) {
19366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19367 }
19368 arg1 = static_cast< wxEventType >(val1);
19369 }
19370 if (obj1) {
19371 ecode2 = SWIG_AsVal_int(obj1, &val2);
19372 if (!SWIG_IsOK(ecode2)) {
19373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19374 }
19375 arg2 = static_cast< int >(val2);
19376 }
19377 if (obj2) {
19378 ecode3 = SWIG_AsVal_int(obj2, &val3);
19379 if (!SWIG_IsOK(ecode3)) {
19380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19381 }
19382 arg3 = static_cast< int >(val3);
19383 }
19384 if (obj3) {
19385 ecode4 = SWIG_AsVal_int(obj3, &val4);
19386 if (!SWIG_IsOK(ecode4)) {
19387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19388 }
19389 arg4 = static_cast< int >(val4);
19390 }
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19405 PyObject *resultobj = 0;
19406 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19407 int result;
19408 void *argp1 = 0 ;
19409 int res1 = 0 ;
19410 PyObject *swig_obj[1] ;
19411
19412 if (!args) SWIG_fail;
19413 swig_obj[0] = args;
19414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19415 if (!SWIG_IsOK(res1)) {
19416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19417 }
19418 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19419 {
19420 PyThreadState* __tstate = wxPyBeginAllowThreads();
19421 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 resultobj = SWIG_From_int(static_cast< int >(result));
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19433 PyObject *resultobj = 0;
19434 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19435 int result;
19436 void *argp1 = 0 ;
19437 int res1 = 0 ;
19438 PyObject *swig_obj[1] ;
19439
19440 if (!args) SWIG_fail;
19441 swig_obj[0] = args;
19442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19443 if (!SWIG_IsOK(res1)) {
19444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19445 }
19446 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 resultobj = SWIG_From_int(static_cast< int >(result));
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj = 0;
19462 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19463 int arg2 ;
19464 void *argp1 = 0 ;
19465 int res1 = 0 ;
19466 int val2 ;
19467 int ecode2 = 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char * kwnames[] = {
19471 (char *) "self",(char *) "orient", NULL
19472 };
19473
19474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19476 if (!SWIG_IsOK(res1)) {
19477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19478 }
19479 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19480 ecode2 = SWIG_AsVal_int(obj1, &val2);
19481 if (!SWIG_IsOK(ecode2)) {
19482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19483 }
19484 arg2 = static_cast< int >(val2);
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 (arg1)->SetOrientation(arg2);
19488 wxPyEndAllowThreads(__tstate);
19489 if (PyErr_Occurred()) SWIG_fail;
19490 }
19491 resultobj = SWIG_Py_Void();
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19499 PyObject *resultobj = 0;
19500 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19501 int arg2 ;
19502 void *argp1 = 0 ;
19503 int res1 = 0 ;
19504 int val2 ;
19505 int ecode2 = 0 ;
19506 PyObject * obj0 = 0 ;
19507 PyObject * obj1 = 0 ;
19508 char * kwnames[] = {
19509 (char *) "self",(char *) "pos", NULL
19510 };
19511
19512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19514 if (!SWIG_IsOK(res1)) {
19515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19516 }
19517 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19518 ecode2 = SWIG_AsVal_int(obj1, &val2);
19519 if (!SWIG_IsOK(ecode2)) {
19520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19521 }
19522 arg2 = static_cast< int >(val2);
19523 {
19524 PyThreadState* __tstate = wxPyBeginAllowThreads();
19525 (arg1)->SetPosition(arg2);
19526 wxPyEndAllowThreads(__tstate);
19527 if (PyErr_Occurred()) SWIG_fail;
19528 }
19529 resultobj = SWIG_Py_Void();
19530 return resultobj;
19531 fail:
19532 return NULL;
19533 }
19534
19535
19536 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19537 PyObject *obj;
19538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19539 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19540 return SWIG_Py_Void();
19541 }
19542
19543 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19544 return SWIG_Python_InitShadowInstance(args);
19545 }
19546
19547 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19548 PyObject *resultobj = 0;
19549 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19550 int arg2 = (int) 0 ;
19551 int arg3 = (int) 0 ;
19552 wxScrollWinEvent *result = 0 ;
19553 int val1 ;
19554 int ecode1 = 0 ;
19555 int val2 ;
19556 int ecode2 = 0 ;
19557 int val3 ;
19558 int ecode3 = 0 ;
19559 PyObject * obj0 = 0 ;
19560 PyObject * obj1 = 0 ;
19561 PyObject * obj2 = 0 ;
19562 char * kwnames[] = {
19563 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19564 };
19565
19566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19567 if (obj0) {
19568 ecode1 = SWIG_AsVal_int(obj0, &val1);
19569 if (!SWIG_IsOK(ecode1)) {
19570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19571 }
19572 arg1 = static_cast< wxEventType >(val1);
19573 }
19574 if (obj1) {
19575 ecode2 = SWIG_AsVal_int(obj1, &val2);
19576 if (!SWIG_IsOK(ecode2)) {
19577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19578 }
19579 arg2 = static_cast< int >(val2);
19580 }
19581 if (obj2) {
19582 ecode3 = SWIG_AsVal_int(obj2, &val3);
19583 if (!SWIG_IsOK(ecode3)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19585 }
19586 arg3 = static_cast< int >(val3);
19587 }
19588 {
19589 PyThreadState* __tstate = wxPyBeginAllowThreads();
19590 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19591 wxPyEndAllowThreads(__tstate);
19592 if (PyErr_Occurred()) SWIG_fail;
19593 }
19594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19595 return resultobj;
19596 fail:
19597 return NULL;
19598 }
19599
19600
19601 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19602 PyObject *resultobj = 0;
19603 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19604 int result;
19605 void *argp1 = 0 ;
19606 int res1 = 0 ;
19607 PyObject *swig_obj[1] ;
19608
19609 if (!args) SWIG_fail;
19610 swig_obj[0] = args;
19611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19612 if (!SWIG_IsOK(res1)) {
19613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19614 }
19615 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19616 {
19617 PyThreadState* __tstate = wxPyBeginAllowThreads();
19618 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19619 wxPyEndAllowThreads(__tstate);
19620 if (PyErr_Occurred()) SWIG_fail;
19621 }
19622 resultobj = SWIG_From_int(static_cast< int >(result));
19623 return resultobj;
19624 fail:
19625 return NULL;
19626 }
19627
19628
19629 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19630 PyObject *resultobj = 0;
19631 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19632 int result;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 PyObject *swig_obj[1] ;
19636
19637 if (!args) SWIG_fail;
19638 swig_obj[0] = args;
19639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19640 if (!SWIG_IsOK(res1)) {
19641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19642 }
19643 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19644 {
19645 PyThreadState* __tstate = wxPyBeginAllowThreads();
19646 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19647 wxPyEndAllowThreads(__tstate);
19648 if (PyErr_Occurred()) SWIG_fail;
19649 }
19650 resultobj = SWIG_From_int(static_cast< int >(result));
19651 return resultobj;
19652 fail:
19653 return NULL;
19654 }
19655
19656
19657 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19658 PyObject *resultobj = 0;
19659 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19660 int arg2 ;
19661 void *argp1 = 0 ;
19662 int res1 = 0 ;
19663 int val2 ;
19664 int ecode2 = 0 ;
19665 PyObject * obj0 = 0 ;
19666 PyObject * obj1 = 0 ;
19667 char * kwnames[] = {
19668 (char *) "self",(char *) "orient", NULL
19669 };
19670
19671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19673 if (!SWIG_IsOK(res1)) {
19674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19675 }
19676 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19677 ecode2 = SWIG_AsVal_int(obj1, &val2);
19678 if (!SWIG_IsOK(ecode2)) {
19679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19680 }
19681 arg2 = static_cast< int >(val2);
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 (arg1)->SetOrientation(arg2);
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 resultobj = SWIG_Py_Void();
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19696 PyObject *resultobj = 0;
19697 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19698 int arg2 ;
19699 void *argp1 = 0 ;
19700 int res1 = 0 ;
19701 int val2 ;
19702 int ecode2 = 0 ;
19703 PyObject * obj0 = 0 ;
19704 PyObject * obj1 = 0 ;
19705 char * kwnames[] = {
19706 (char *) "self",(char *) "pos", NULL
19707 };
19708
19709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19711 if (!SWIG_IsOK(res1)) {
19712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19713 }
19714 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19715 ecode2 = SWIG_AsVal_int(obj1, &val2);
19716 if (!SWIG_IsOK(ecode2)) {
19717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19718 }
19719 arg2 = static_cast< int >(val2);
19720 {
19721 PyThreadState* __tstate = wxPyBeginAllowThreads();
19722 (arg1)->SetPosition(arg2);
19723 wxPyEndAllowThreads(__tstate);
19724 if (PyErr_Occurred()) SWIG_fail;
19725 }
19726 resultobj = SWIG_Py_Void();
19727 return resultobj;
19728 fail:
19729 return NULL;
19730 }
19731
19732
19733 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19734 PyObject *obj;
19735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19736 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19737 return SWIG_Py_Void();
19738 }
19739
19740 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 return SWIG_Python_InitShadowInstance(args);
19742 }
19743
19744 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19745 PyObject *resultobj = 0;
19746 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19747 wxMouseEvent *result = 0 ;
19748 int val1 ;
19749 int ecode1 = 0 ;
19750 PyObject * obj0 = 0 ;
19751 char * kwnames[] = {
19752 (char *) "mouseType", NULL
19753 };
19754
19755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19756 if (obj0) {
19757 ecode1 = SWIG_AsVal_int(obj0, &val1);
19758 if (!SWIG_IsOK(ecode1)) {
19759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19760 }
19761 arg1 = static_cast< wxEventType >(val1);
19762 }
19763 {
19764 PyThreadState* __tstate = wxPyBeginAllowThreads();
19765 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19766 wxPyEndAllowThreads(__tstate);
19767 if (PyErr_Occurred()) SWIG_fail;
19768 }
19769 {
19770 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19771 }
19772 return resultobj;
19773 fail:
19774 return NULL;
19775 }
19776
19777
19778 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19779 PyObject *resultobj = 0;
19780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19781 bool result;
19782 void *argp1 = 0 ;
19783 int res1 = 0 ;
19784 PyObject *swig_obj[1] ;
19785
19786 if (!args) SWIG_fail;
19787 swig_obj[0] = args;
19788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19789 if (!SWIG_IsOK(res1)) {
19790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19791 }
19792 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 {
19800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19801 }
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19809 PyObject *resultobj = 0;
19810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19811 int arg2 = (int) wxMOUSE_BTN_ANY ;
19812 bool result;
19813 void *argp1 = 0 ;
19814 int res1 = 0 ;
19815 int val2 ;
19816 int ecode2 = 0 ;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 char * kwnames[] = {
19820 (char *) "self",(char *) "but", NULL
19821 };
19822
19823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19825 if (!SWIG_IsOK(res1)) {
19826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19827 }
19828 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19829 if (obj1) {
19830 ecode2 = SWIG_AsVal_int(obj1, &val2);
19831 if (!SWIG_IsOK(ecode2)) {
19832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19833 }
19834 arg2 = static_cast< int >(val2);
19835 }
19836 {
19837 PyThreadState* __tstate = wxPyBeginAllowThreads();
19838 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj = 0;
19853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19854 int arg2 = (int) wxMOUSE_BTN_ANY ;
19855 bool result;
19856 void *argp1 = 0 ;
19857 int res1 = 0 ;
19858 int val2 ;
19859 int ecode2 = 0 ;
19860 PyObject * obj0 = 0 ;
19861 PyObject * obj1 = 0 ;
19862 char * kwnames[] = {
19863 (char *) "self",(char *) "but", NULL
19864 };
19865
19866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19868 if (!SWIG_IsOK(res1)) {
19869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19870 }
19871 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19872 if (obj1) {
19873 ecode2 = SWIG_AsVal_int(obj1, &val2);
19874 if (!SWIG_IsOK(ecode2)) {
19875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19876 }
19877 arg2 = static_cast< int >(val2);
19878 }
19879 {
19880 PyThreadState* __tstate = wxPyBeginAllowThreads();
19881 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19882 wxPyEndAllowThreads(__tstate);
19883 if (PyErr_Occurred()) SWIG_fail;
19884 }
19885 {
19886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19887 }
19888 return resultobj;
19889 fail:
19890 return NULL;
19891 }
19892
19893
19894 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19895 PyObject *resultobj = 0;
19896 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19897 int arg2 = (int) wxMOUSE_BTN_ANY ;
19898 bool result;
19899 void *argp1 = 0 ;
19900 int res1 = 0 ;
19901 int val2 ;
19902 int ecode2 = 0 ;
19903 PyObject * obj0 = 0 ;
19904 PyObject * obj1 = 0 ;
19905 char * kwnames[] = {
19906 (char *) "self",(char *) "but", NULL
19907 };
19908
19909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19911 if (!SWIG_IsOK(res1)) {
19912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19913 }
19914 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19915 if (obj1) {
19916 ecode2 = SWIG_AsVal_int(obj1, &val2);
19917 if (!SWIG_IsOK(ecode2)) {
19918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19919 }
19920 arg2 = static_cast< int >(val2);
19921 }
19922 {
19923 PyThreadState* __tstate = wxPyBeginAllowThreads();
19924 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 {
19929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19930 }
19931 return resultobj;
19932 fail:
19933 return NULL;
19934 }
19935
19936
19937 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19938 PyObject *resultobj = 0;
19939 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19940 int arg2 ;
19941 bool result;
19942 void *argp1 = 0 ;
19943 int res1 = 0 ;
19944 int val2 ;
19945 int ecode2 = 0 ;
19946 PyObject * obj0 = 0 ;
19947 PyObject * obj1 = 0 ;
19948 char * kwnames[] = {
19949 (char *) "self",(char *) "button", NULL
19950 };
19951
19952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19954 if (!SWIG_IsOK(res1)) {
19955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19956 }
19957 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19958 ecode2 = SWIG_AsVal_int(obj1, &val2);
19959 if (!SWIG_IsOK(ecode2)) {
19960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19961 }
19962 arg2 = static_cast< int >(val2);
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 {
19970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19971 }
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19979 PyObject *resultobj = 0;
19980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19981 int arg2 ;
19982 bool result;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 int val2 ;
19986 int ecode2 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char * kwnames[] = {
19990 (char *) "self",(char *) "but", NULL
19991 };
19992
19993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19997 }
19998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19999 ecode2 = SWIG_AsVal_int(obj1, &val2);
20000 if (!SWIG_IsOK(ecode2)) {
20001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20002 }
20003 arg2 = static_cast< int >(val2);
20004 {
20005 PyThreadState* __tstate = wxPyBeginAllowThreads();
20006 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20007 wxPyEndAllowThreads(__tstate);
20008 if (PyErr_Occurred()) SWIG_fail;
20009 }
20010 {
20011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20012 }
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20020 PyObject *resultobj = 0;
20021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20022 int result;
20023 void *argp1 = 0 ;
20024 int res1 = 0 ;
20025 PyObject *swig_obj[1] ;
20026
20027 if (!args) SWIG_fail;
20028 swig_obj[0] = args;
20029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20030 if (!SWIG_IsOK(res1)) {
20031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20032 }
20033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20034 {
20035 PyThreadState* __tstate = wxPyBeginAllowThreads();
20036 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20037 wxPyEndAllowThreads(__tstate);
20038 if (PyErr_Occurred()) SWIG_fail;
20039 }
20040 resultobj = SWIG_From_int(static_cast< int >(result));
20041 return resultobj;
20042 fail:
20043 return NULL;
20044 }
20045
20046
20047 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20048 PyObject *resultobj = 0;
20049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20050 bool result;
20051 void *argp1 = 0 ;
20052 int res1 = 0 ;
20053 PyObject *swig_obj[1] ;
20054
20055 if (!args) SWIG_fail;
20056 swig_obj[0] = args;
20057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20058 if (!SWIG_IsOK(res1)) {
20059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20060 }
20061 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20062 {
20063 PyThreadState* __tstate = wxPyBeginAllowThreads();
20064 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20065 wxPyEndAllowThreads(__tstate);
20066 if (PyErr_Occurred()) SWIG_fail;
20067 }
20068 {
20069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20070 }
20071 return resultobj;
20072 fail:
20073 return NULL;
20074 }
20075
20076
20077 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20078 PyObject *resultobj = 0;
20079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20080 bool result;
20081 void *argp1 = 0 ;
20082 int res1 = 0 ;
20083 PyObject *swig_obj[1] ;
20084
20085 if (!args) SWIG_fail;
20086 swig_obj[0] = args;
20087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20088 if (!SWIG_IsOK(res1)) {
20089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20090 }
20091 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20092 {
20093 PyThreadState* __tstate = wxPyBeginAllowThreads();
20094 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 {
20099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20100 }
20101 return resultobj;
20102 fail:
20103 return NULL;
20104 }
20105
20106
20107 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108 PyObject *resultobj = 0;
20109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20110 bool result;
20111 void *argp1 = 0 ;
20112 int res1 = 0 ;
20113 PyObject *swig_obj[1] ;
20114
20115 if (!args) SWIG_fail;
20116 swig_obj[0] = args;
20117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20118 if (!SWIG_IsOK(res1)) {
20119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20120 }
20121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20122 {
20123 PyThreadState* __tstate = wxPyBeginAllowThreads();
20124 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20125 wxPyEndAllowThreads(__tstate);
20126 if (PyErr_Occurred()) SWIG_fail;
20127 }
20128 {
20129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20138 PyObject *resultobj = 0;
20139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20140 bool result;
20141 void *argp1 = 0 ;
20142 int res1 = 0 ;
20143 PyObject *swig_obj[1] ;
20144
20145 if (!args) SWIG_fail;
20146 swig_obj[0] = args;
20147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20148 if (!SWIG_IsOK(res1)) {
20149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20150 }
20151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20152 {
20153 PyThreadState* __tstate = wxPyBeginAllowThreads();
20154 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20155 wxPyEndAllowThreads(__tstate);
20156 if (PyErr_Occurred()) SWIG_fail;
20157 }
20158 {
20159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20160 }
20161 return resultobj;
20162 fail:
20163 return NULL;
20164 }
20165
20166
20167 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 PyObject *resultobj = 0;
20169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20170 bool result;
20171 void *argp1 = 0 ;
20172 int res1 = 0 ;
20173 PyObject *swig_obj[1] ;
20174
20175 if (!args) SWIG_fail;
20176 swig_obj[0] = args;
20177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20178 if (!SWIG_IsOK(res1)) {
20179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20180 }
20181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20182 {
20183 PyThreadState* __tstate = wxPyBeginAllowThreads();
20184 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20185 wxPyEndAllowThreads(__tstate);
20186 if (PyErr_Occurred()) SWIG_fail;
20187 }
20188 {
20189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20190 }
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20198 PyObject *resultobj = 0;
20199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20200 bool result;
20201 void *argp1 = 0 ;
20202 int res1 = 0 ;
20203 PyObject *swig_obj[1] ;
20204
20205 if (!args) SWIG_fail;
20206 swig_obj[0] = args;
20207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20208 if (!SWIG_IsOK(res1)) {
20209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20210 }
20211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20212 {
20213 PyThreadState* __tstate = wxPyBeginAllowThreads();
20214 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20215 wxPyEndAllowThreads(__tstate);
20216 if (PyErr_Occurred()) SWIG_fail;
20217 }
20218 {
20219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20220 }
20221 return resultobj;
20222 fail:
20223 return NULL;
20224 }
20225
20226
20227 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20228 PyObject *resultobj = 0;
20229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20230 bool result;
20231 void *argp1 = 0 ;
20232 int res1 = 0 ;
20233 PyObject *swig_obj[1] ;
20234
20235 if (!args) SWIG_fail;
20236 swig_obj[0] = args;
20237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20238 if (!SWIG_IsOK(res1)) {
20239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20240 }
20241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20242 {
20243 PyThreadState* __tstate = wxPyBeginAllowThreads();
20244 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 {
20249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20250 }
20251 return resultobj;
20252 fail:
20253 return NULL;
20254 }
20255
20256
20257 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *resultobj = 0;
20259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20260 bool result;
20261 void *argp1 = 0 ;
20262 int res1 = 0 ;
20263 PyObject *swig_obj[1] ;
20264
20265 if (!args) SWIG_fail;
20266 swig_obj[0] = args;
20267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20268 if (!SWIG_IsOK(res1)) {
20269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20270 }
20271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20272 {
20273 PyThreadState* __tstate = wxPyBeginAllowThreads();
20274 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20275 wxPyEndAllowThreads(__tstate);
20276 if (PyErr_Occurred()) SWIG_fail;
20277 }
20278 {
20279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20280 }
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20290 bool result;
20291 void *argp1 = 0 ;
20292 int res1 = 0 ;
20293 PyObject *swig_obj[1] ;
20294
20295 if (!args) SWIG_fail;
20296 swig_obj[0] = args;
20297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20298 if (!SWIG_IsOK(res1)) {
20299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20300 }
20301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20302 {
20303 PyThreadState* __tstate = wxPyBeginAllowThreads();
20304 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 {
20309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20310 }
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20318 PyObject *resultobj = 0;
20319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20320 bool result;
20321 void *argp1 = 0 ;
20322 int res1 = 0 ;
20323 PyObject *swig_obj[1] ;
20324
20325 if (!args) SWIG_fail;
20326 swig_obj[0] = args;
20327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20328 if (!SWIG_IsOK(res1)) {
20329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20330 }
20331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 {
20339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20340 }
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20348 PyObject *resultobj = 0;
20349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20350 bool result;
20351 void *argp1 = 0 ;
20352 int res1 = 0 ;
20353 PyObject *swig_obj[1] ;
20354
20355 if (!args) SWIG_fail;
20356 swig_obj[0] = args;
20357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20358 if (!SWIG_IsOK(res1)) {
20359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20360 }
20361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20365 wxPyEndAllowThreads(__tstate);
20366 if (PyErr_Occurred()) SWIG_fail;
20367 }
20368 {
20369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20370 }
20371 return resultobj;
20372 fail:
20373 return NULL;
20374 }
20375
20376
20377 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20378 PyObject *resultobj = 0;
20379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20380 bool result;
20381 void *argp1 = 0 ;
20382 int res1 = 0 ;
20383 PyObject *swig_obj[1] ;
20384
20385 if (!args) SWIG_fail;
20386 swig_obj[0] = args;
20387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20388 if (!SWIG_IsOK(res1)) {
20389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20390 }
20391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 {
20399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20400 }
20401 return resultobj;
20402 fail:
20403 return NULL;
20404 }
20405
20406
20407 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 PyObject *resultobj = 0;
20409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20410 bool result;
20411 void *argp1 = 0 ;
20412 int res1 = 0 ;
20413 PyObject *swig_obj[1] ;
20414
20415 if (!args) SWIG_fail;
20416 swig_obj[0] = args;
20417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20418 if (!SWIG_IsOK(res1)) {
20419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20420 }
20421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20425 wxPyEndAllowThreads(__tstate);
20426 if (PyErr_Occurred()) SWIG_fail;
20427 }
20428 {
20429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20430 }
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20438 PyObject *resultobj = 0;
20439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20440 bool result;
20441 void *argp1 = 0 ;
20442 int res1 = 0 ;
20443 PyObject *swig_obj[1] ;
20444
20445 if (!args) SWIG_fail;
20446 swig_obj[0] = args;
20447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20448 if (!SWIG_IsOK(res1)) {
20449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20450 }
20451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20452 {
20453 PyThreadState* __tstate = wxPyBeginAllowThreads();
20454 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20455 wxPyEndAllowThreads(__tstate);
20456 if (PyErr_Occurred()) SWIG_fail;
20457 }
20458 {
20459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20460 }
20461 return resultobj;
20462 fail:
20463 return NULL;
20464 }
20465
20466
20467 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20468 PyObject *resultobj = 0;
20469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20470 bool result;
20471 void *argp1 = 0 ;
20472 int res1 = 0 ;
20473 PyObject *swig_obj[1] ;
20474
20475 if (!args) SWIG_fail;
20476 swig_obj[0] = args;
20477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20478 if (!SWIG_IsOK(res1)) {
20479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20480 }
20481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (bool)(arg1)->LeftIsDown();
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 {
20489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20490 }
20491 return resultobj;
20492 fail:
20493 return NULL;
20494 }
20495
20496
20497 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20498 PyObject *resultobj = 0;
20499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20500 bool result;
20501 void *argp1 = 0 ;
20502 int res1 = 0 ;
20503 PyObject *swig_obj[1] ;
20504
20505 if (!args) SWIG_fail;
20506 swig_obj[0] = args;
20507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20508 if (!SWIG_IsOK(res1)) {
20509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20510 }
20511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 result = (bool)(arg1)->MiddleIsDown();
20515 wxPyEndAllowThreads(__tstate);
20516 if (PyErr_Occurred()) SWIG_fail;
20517 }
20518 {
20519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20520 }
20521 return resultobj;
20522 fail:
20523 return NULL;
20524 }
20525
20526
20527 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20528 PyObject *resultobj = 0;
20529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20530 bool result;
20531 void *argp1 = 0 ;
20532 int res1 = 0 ;
20533 PyObject *swig_obj[1] ;
20534
20535 if (!args) SWIG_fail;
20536 swig_obj[0] = args;
20537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20538 if (!SWIG_IsOK(res1)) {
20539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20540 }
20541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (bool)(arg1)->RightIsDown();
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 {
20549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20550 }
20551 return resultobj;
20552 fail:
20553 return NULL;
20554 }
20555
20556
20557 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20558 PyObject *resultobj = 0;
20559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20560 bool result;
20561 void *argp1 = 0 ;
20562 int res1 = 0 ;
20563 PyObject *swig_obj[1] ;
20564
20565 if (!args) SWIG_fail;
20566 swig_obj[0] = args;
20567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20568 if (!SWIG_IsOK(res1)) {
20569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20570 }
20571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20575 wxPyEndAllowThreads(__tstate);
20576 if (PyErr_Occurred()) SWIG_fail;
20577 }
20578 {
20579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20580 }
20581 return resultobj;
20582 fail:
20583 return NULL;
20584 }
20585
20586
20587 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20588 PyObject *resultobj = 0;
20589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20590 bool result;
20591 void *argp1 = 0 ;
20592 int res1 = 0 ;
20593 PyObject *swig_obj[1] ;
20594
20595 if (!args) SWIG_fail;
20596 swig_obj[0] = args;
20597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20598 if (!SWIG_IsOK(res1)) {
20599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20600 }
20601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 {
20609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20610 }
20611 return resultobj;
20612 fail:
20613 return NULL;
20614 }
20615
20616
20617 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20618 PyObject *resultobj = 0;
20619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20620 bool result;
20621 void *argp1 = 0 ;
20622 int res1 = 0 ;
20623 PyObject *swig_obj[1] ;
20624
20625 if (!args) SWIG_fail;
20626 swig_obj[0] = args;
20627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20628 if (!SWIG_IsOK(res1)) {
20629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20630 }
20631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 {
20639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20640 }
20641 return resultobj;
20642 fail:
20643 return NULL;
20644 }
20645
20646
20647 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20648 PyObject *resultobj = 0;
20649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20650 bool result;
20651 void *argp1 = 0 ;
20652 int res1 = 0 ;
20653 PyObject *swig_obj[1] ;
20654
20655 if (!args) SWIG_fail;
20656 swig_obj[0] = args;
20657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20658 if (!SWIG_IsOK(res1)) {
20659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20660 }
20661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20662 {
20663 PyThreadState* __tstate = wxPyBeginAllowThreads();
20664 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20670 }
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20678 PyObject *resultobj = 0;
20679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20680 wxPoint result;
20681 void *argp1 = 0 ;
20682 int res1 = 0 ;
20683 PyObject *swig_obj[1] ;
20684
20685 if (!args) SWIG_fail;
20686 swig_obj[0] = args;
20687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20688 if (!SWIG_IsOK(res1)) {
20689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20690 }
20691 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 result = (arg1)->GetPosition();
20695 wxPyEndAllowThreads(__tstate);
20696 if (PyErr_Occurred()) SWIG_fail;
20697 }
20698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20699 return resultobj;
20700 fail:
20701 return NULL;
20702 }
20703
20704
20705 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20706 PyObject *resultobj = 0;
20707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20708 long *arg2 = (long *) 0 ;
20709 long *arg3 = (long *) 0 ;
20710 void *argp1 = 0 ;
20711 int res1 = 0 ;
20712 long temp2 ;
20713 int res2 = SWIG_TMPOBJ ;
20714 long temp3 ;
20715 int res3 = SWIG_TMPOBJ ;
20716 PyObject *swig_obj[1] ;
20717
20718 arg2 = &temp2;
20719 arg3 = &temp3;
20720 if (!args) SWIG_fail;
20721 swig_obj[0] = args;
20722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20723 if (!SWIG_IsOK(res1)) {
20724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20725 }
20726 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 (arg1)->GetPosition(arg2,arg3);
20730 wxPyEndAllowThreads(__tstate);
20731 if (PyErr_Occurred()) SWIG_fail;
20732 }
20733 resultobj = SWIG_Py_Void();
20734 if (SWIG_IsTmpObj(res2)) {
20735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20736 } else {
20737 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20739 }
20740 if (SWIG_IsTmpObj(res3)) {
20741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20742 } else {
20743 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20745 }
20746 return resultobj;
20747 fail:
20748 return NULL;
20749 }
20750
20751
20752 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20753 PyObject *resultobj = 0;
20754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20755 wxDC *arg2 = 0 ;
20756 wxPoint result;
20757 void *argp1 = 0 ;
20758 int res1 = 0 ;
20759 void *argp2 = 0 ;
20760 int res2 = 0 ;
20761 PyObject * obj0 = 0 ;
20762 PyObject * obj1 = 0 ;
20763 char * kwnames[] = {
20764 (char *) "self",(char *) "dc", NULL
20765 };
20766
20767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20769 if (!SWIG_IsOK(res1)) {
20770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20771 }
20772 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20773 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20774 if (!SWIG_IsOK(res2)) {
20775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20776 }
20777 if (!argp2) {
20778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20779 }
20780 arg2 = reinterpret_cast< wxDC * >(argp2);
20781 {
20782 PyThreadState* __tstate = wxPyBeginAllowThreads();
20783 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20784 wxPyEndAllowThreads(__tstate);
20785 if (PyErr_Occurred()) SWIG_fail;
20786 }
20787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20788 return resultobj;
20789 fail:
20790 return NULL;
20791 }
20792
20793
20794 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20795 PyObject *resultobj = 0;
20796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20797 int result;
20798 void *argp1 = 0 ;
20799 int res1 = 0 ;
20800 PyObject *swig_obj[1] ;
20801
20802 if (!args) SWIG_fail;
20803 swig_obj[0] = args;
20804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20805 if (!SWIG_IsOK(res1)) {
20806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20807 }
20808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = (int)((wxMouseEvent const *)arg1)->GetX();
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 resultobj = SWIG_From_int(static_cast< int >(result));
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20823 PyObject *resultobj = 0;
20824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20825 int result;
20826 void *argp1 = 0 ;
20827 int res1 = 0 ;
20828 PyObject *swig_obj[1] ;
20829
20830 if (!args) SWIG_fail;
20831 swig_obj[0] = args;
20832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20835 }
20836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (int)((wxMouseEvent const *)arg1)->GetY();
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 resultobj = SWIG_From_int(static_cast< int >(result));
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20851 PyObject *resultobj = 0;
20852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20853 int result;
20854 void *argp1 = 0 ;
20855 int res1 = 0 ;
20856 PyObject *swig_obj[1] ;
20857
20858 if (!args) SWIG_fail;
20859 swig_obj[0] = args;
20860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20861 if (!SWIG_IsOK(res1)) {
20862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20863 }
20864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20865 {
20866 PyThreadState* __tstate = wxPyBeginAllowThreads();
20867 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20868 wxPyEndAllowThreads(__tstate);
20869 if (PyErr_Occurred()) SWIG_fail;
20870 }
20871 resultobj = SWIG_From_int(static_cast< int >(result));
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20879 PyObject *resultobj = 0;
20880 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20881 int result;
20882 void *argp1 = 0 ;
20883 int res1 = 0 ;
20884 PyObject *swig_obj[1] ;
20885
20886 if (!args) SWIG_fail;
20887 swig_obj[0] = args;
20888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20889 if (!SWIG_IsOK(res1)) {
20890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20891 }
20892 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20893 {
20894 PyThreadState* __tstate = wxPyBeginAllowThreads();
20895 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 resultobj = SWIG_From_int(static_cast< int >(result));
20900 return resultobj;
20901 fail:
20902 return NULL;
20903 }
20904
20905
20906 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20907 PyObject *resultobj = 0;
20908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20909 int result;
20910 void *argp1 = 0 ;
20911 int res1 = 0 ;
20912 PyObject *swig_obj[1] ;
20913
20914 if (!args) SWIG_fail;
20915 swig_obj[0] = args;
20916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20917 if (!SWIG_IsOK(res1)) {
20918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20919 }
20920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20921 {
20922 PyThreadState* __tstate = wxPyBeginAllowThreads();
20923 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 resultobj = SWIG_From_int(static_cast< int >(result));
20928 return resultobj;
20929 fail:
20930 return NULL;
20931 }
20932
20933
20934 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20935 PyObject *resultobj = 0;
20936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20937 bool result;
20938 void *argp1 = 0 ;
20939 int res1 = 0 ;
20940 PyObject *swig_obj[1] ;
20941
20942 if (!args) SWIG_fail;
20943 swig_obj[0] = args;
20944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20945 if (!SWIG_IsOK(res1)) {
20946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20947 }
20948 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20949 {
20950 PyThreadState* __tstate = wxPyBeginAllowThreads();
20951 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20965 PyObject *resultobj = 0;
20966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20967 int arg2 ;
20968 void *argp1 = 0 ;
20969 int res1 = 0 ;
20970 int val2 ;
20971 int ecode2 = 0 ;
20972 PyObject *swig_obj[2] ;
20973
20974 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20976 if (!SWIG_IsOK(res1)) {
20977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20978 }
20979 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20980 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20981 if (!SWIG_IsOK(ecode2)) {
20982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20983 }
20984 arg2 = static_cast< int >(val2);
20985 if (arg1) (arg1)->m_x = arg2;
20986
20987 resultobj = SWIG_Py_Void();
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20995 PyObject *resultobj = 0;
20996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20997 int result;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 PyObject *swig_obj[1] ;
21001
21002 if (!args) SWIG_fail;
21003 swig_obj[0] = args;
21004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21005 if (!SWIG_IsOK(res1)) {
21006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21007 }
21008 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21009 result = (int) ((arg1)->m_x);
21010 resultobj = SWIG_From_int(static_cast< int >(result));
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21018 PyObject *resultobj = 0;
21019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21020 int arg2 ;
21021 void *argp1 = 0 ;
21022 int res1 = 0 ;
21023 int val2 ;
21024 int ecode2 = 0 ;
21025 PyObject *swig_obj[2] ;
21026
21027 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21029 if (!SWIG_IsOK(res1)) {
21030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21031 }
21032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21033 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21034 if (!SWIG_IsOK(ecode2)) {
21035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21036 }
21037 arg2 = static_cast< int >(val2);
21038 if (arg1) (arg1)->m_y = arg2;
21039
21040 resultobj = SWIG_Py_Void();
21041 return resultobj;
21042 fail:
21043 return NULL;
21044 }
21045
21046
21047 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21050 int result;
21051 void *argp1 = 0 ;
21052 int res1 = 0 ;
21053 PyObject *swig_obj[1] ;
21054
21055 if (!args) SWIG_fail;
21056 swig_obj[0] = args;
21057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21058 if (!SWIG_IsOK(res1)) {
21059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21060 }
21061 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21062 result = (int) ((arg1)->m_y);
21063 resultobj = SWIG_From_int(static_cast< int >(result));
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21071 PyObject *resultobj = 0;
21072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21073 bool arg2 ;
21074 void *argp1 = 0 ;
21075 int res1 = 0 ;
21076 bool val2 ;
21077 int ecode2 = 0 ;
21078 PyObject *swig_obj[2] ;
21079
21080 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21082 if (!SWIG_IsOK(res1)) {
21083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21084 }
21085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21086 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21087 if (!SWIG_IsOK(ecode2)) {
21088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21089 }
21090 arg2 = static_cast< bool >(val2);
21091 if (arg1) (arg1)->m_leftDown = arg2;
21092
21093 resultobj = SWIG_Py_Void();
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21101 PyObject *resultobj = 0;
21102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21103 bool result;
21104 void *argp1 = 0 ;
21105 int res1 = 0 ;
21106 PyObject *swig_obj[1] ;
21107
21108 if (!args) SWIG_fail;
21109 swig_obj[0] = args;
21110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21111 if (!SWIG_IsOK(res1)) {
21112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21113 }
21114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21115 result = (bool) ((arg1)->m_leftDown);
21116 {
21117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21118 }
21119 return resultobj;
21120 fail:
21121 return NULL;
21122 }
21123
21124
21125 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21126 PyObject *resultobj = 0;
21127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21128 bool arg2 ;
21129 void *argp1 = 0 ;
21130 int res1 = 0 ;
21131 bool val2 ;
21132 int ecode2 = 0 ;
21133 PyObject *swig_obj[2] ;
21134
21135 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21137 if (!SWIG_IsOK(res1)) {
21138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21139 }
21140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21141 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21142 if (!SWIG_IsOK(ecode2)) {
21143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21144 }
21145 arg2 = static_cast< bool >(val2);
21146 if (arg1) (arg1)->m_middleDown = arg2;
21147
21148 resultobj = SWIG_Py_Void();
21149 return resultobj;
21150 fail:
21151 return NULL;
21152 }
21153
21154
21155 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21156 PyObject *resultobj = 0;
21157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21158 bool result;
21159 void *argp1 = 0 ;
21160 int res1 = 0 ;
21161 PyObject *swig_obj[1] ;
21162
21163 if (!args) SWIG_fail;
21164 swig_obj[0] = args;
21165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21166 if (!SWIG_IsOK(res1)) {
21167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21168 }
21169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21170 result = (bool) ((arg1)->m_middleDown);
21171 {
21172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21173 }
21174 return resultobj;
21175 fail:
21176 return NULL;
21177 }
21178
21179
21180 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21181 PyObject *resultobj = 0;
21182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21183 bool arg2 ;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 bool val2 ;
21187 int ecode2 = 0 ;
21188 PyObject *swig_obj[2] ;
21189
21190 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21192 if (!SWIG_IsOK(res1)) {
21193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21194 }
21195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21196 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21197 if (!SWIG_IsOK(ecode2)) {
21198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21199 }
21200 arg2 = static_cast< bool >(val2);
21201 if (arg1) (arg1)->m_rightDown = arg2;
21202
21203 resultobj = SWIG_Py_Void();
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21211 PyObject *resultobj = 0;
21212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21213 bool result;
21214 void *argp1 = 0 ;
21215 int res1 = 0 ;
21216 PyObject *swig_obj[1] ;
21217
21218 if (!args) SWIG_fail;
21219 swig_obj[0] = args;
21220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21221 if (!SWIG_IsOK(res1)) {
21222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21223 }
21224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21225 result = (bool) ((arg1)->m_rightDown);
21226 {
21227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21228 }
21229 return resultobj;
21230 fail:
21231 return NULL;
21232 }
21233
21234
21235 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21236 PyObject *resultobj = 0;
21237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21238 bool arg2 ;
21239 void *argp1 = 0 ;
21240 int res1 = 0 ;
21241 bool val2 ;
21242 int ecode2 = 0 ;
21243 PyObject *swig_obj[2] ;
21244
21245 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21247 if (!SWIG_IsOK(res1)) {
21248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21249 }
21250 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21251 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21252 if (!SWIG_IsOK(ecode2)) {
21253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21254 }
21255 arg2 = static_cast< bool >(val2);
21256 if (arg1) (arg1)->m_controlDown = arg2;
21257
21258 resultobj = SWIG_Py_Void();
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21266 PyObject *resultobj = 0;
21267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21268 bool result;
21269 void *argp1 = 0 ;
21270 int res1 = 0 ;
21271 PyObject *swig_obj[1] ;
21272
21273 if (!args) SWIG_fail;
21274 swig_obj[0] = args;
21275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21276 if (!SWIG_IsOK(res1)) {
21277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21278 }
21279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21280 result = (bool) ((arg1)->m_controlDown);
21281 {
21282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21283 }
21284 return resultobj;
21285 fail:
21286 return NULL;
21287 }
21288
21289
21290 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21291 PyObject *resultobj = 0;
21292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21293 bool arg2 ;
21294 void *argp1 = 0 ;
21295 int res1 = 0 ;
21296 bool val2 ;
21297 int ecode2 = 0 ;
21298 PyObject *swig_obj[2] ;
21299
21300 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21302 if (!SWIG_IsOK(res1)) {
21303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21304 }
21305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21306 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21307 if (!SWIG_IsOK(ecode2)) {
21308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21309 }
21310 arg2 = static_cast< bool >(val2);
21311 if (arg1) (arg1)->m_shiftDown = arg2;
21312
21313 resultobj = SWIG_Py_Void();
21314 return resultobj;
21315 fail:
21316 return NULL;
21317 }
21318
21319
21320 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21321 PyObject *resultobj = 0;
21322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21323 bool result;
21324 void *argp1 = 0 ;
21325 int res1 = 0 ;
21326 PyObject *swig_obj[1] ;
21327
21328 if (!args) SWIG_fail;
21329 swig_obj[0] = args;
21330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21331 if (!SWIG_IsOK(res1)) {
21332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21333 }
21334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21335 result = (bool) ((arg1)->m_shiftDown);
21336 {
21337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21338 }
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21346 PyObject *resultobj = 0;
21347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21348 bool arg2 ;
21349 void *argp1 = 0 ;
21350 int res1 = 0 ;
21351 bool val2 ;
21352 int ecode2 = 0 ;
21353 PyObject *swig_obj[2] ;
21354
21355 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21359 }
21360 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21361 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21362 if (!SWIG_IsOK(ecode2)) {
21363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21364 }
21365 arg2 = static_cast< bool >(val2);
21366 if (arg1) (arg1)->m_altDown = arg2;
21367
21368 resultobj = SWIG_Py_Void();
21369 return resultobj;
21370 fail:
21371 return NULL;
21372 }
21373
21374
21375 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21376 PyObject *resultobj = 0;
21377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21378 bool result;
21379 void *argp1 = 0 ;
21380 int res1 = 0 ;
21381 PyObject *swig_obj[1] ;
21382
21383 if (!args) SWIG_fail;
21384 swig_obj[0] = args;
21385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21386 if (!SWIG_IsOK(res1)) {
21387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21388 }
21389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21390 result = (bool) ((arg1)->m_altDown);
21391 {
21392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21393 }
21394 return resultobj;
21395 fail:
21396 return NULL;
21397 }
21398
21399
21400 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21401 PyObject *resultobj = 0;
21402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21403 bool arg2 ;
21404 void *argp1 = 0 ;
21405 int res1 = 0 ;
21406 bool val2 ;
21407 int ecode2 = 0 ;
21408 PyObject *swig_obj[2] ;
21409
21410 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21412 if (!SWIG_IsOK(res1)) {
21413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21414 }
21415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21416 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21417 if (!SWIG_IsOK(ecode2)) {
21418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21419 }
21420 arg2 = static_cast< bool >(val2);
21421 if (arg1) (arg1)->m_metaDown = arg2;
21422
21423 resultobj = SWIG_Py_Void();
21424 return resultobj;
21425 fail:
21426 return NULL;
21427 }
21428
21429
21430 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21431 PyObject *resultobj = 0;
21432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21433 bool result;
21434 void *argp1 = 0 ;
21435 int res1 = 0 ;
21436 PyObject *swig_obj[1] ;
21437
21438 if (!args) SWIG_fail;
21439 swig_obj[0] = args;
21440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21441 if (!SWIG_IsOK(res1)) {
21442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21443 }
21444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21445 result = (bool) ((arg1)->m_metaDown);
21446 {
21447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21448 }
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21456 PyObject *resultobj = 0;
21457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21458 int arg2 ;
21459 void *argp1 = 0 ;
21460 int res1 = 0 ;
21461 int val2 ;
21462 int ecode2 = 0 ;
21463 PyObject *swig_obj[2] ;
21464
21465 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21467 if (!SWIG_IsOK(res1)) {
21468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21469 }
21470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21471 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21472 if (!SWIG_IsOK(ecode2)) {
21473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21474 }
21475 arg2 = static_cast< int >(val2);
21476 if (arg1) (arg1)->m_wheelRotation = arg2;
21477
21478 resultobj = SWIG_Py_Void();
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21486 PyObject *resultobj = 0;
21487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21488 int result;
21489 void *argp1 = 0 ;
21490 int res1 = 0 ;
21491 PyObject *swig_obj[1] ;
21492
21493 if (!args) SWIG_fail;
21494 swig_obj[0] = args;
21495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21496 if (!SWIG_IsOK(res1)) {
21497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21498 }
21499 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21500 result = (int) ((arg1)->m_wheelRotation);
21501 resultobj = SWIG_From_int(static_cast< int >(result));
21502 return resultobj;
21503 fail:
21504 return NULL;
21505 }
21506
21507
21508 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21509 PyObject *resultobj = 0;
21510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21511 int arg2 ;
21512 void *argp1 = 0 ;
21513 int res1 = 0 ;
21514 int val2 ;
21515 int ecode2 = 0 ;
21516 PyObject *swig_obj[2] ;
21517
21518 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21520 if (!SWIG_IsOK(res1)) {
21521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21522 }
21523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21524 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21525 if (!SWIG_IsOK(ecode2)) {
21526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21527 }
21528 arg2 = static_cast< int >(val2);
21529 if (arg1) (arg1)->m_wheelDelta = arg2;
21530
21531 resultobj = SWIG_Py_Void();
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21539 PyObject *resultobj = 0;
21540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21541 int result;
21542 void *argp1 = 0 ;
21543 int res1 = 0 ;
21544 PyObject *swig_obj[1] ;
21545
21546 if (!args) SWIG_fail;
21547 swig_obj[0] = args;
21548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21549 if (!SWIG_IsOK(res1)) {
21550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21551 }
21552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21553 result = (int) ((arg1)->m_wheelDelta);
21554 resultobj = SWIG_From_int(static_cast< int >(result));
21555 return resultobj;
21556 fail:
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21562 PyObject *resultobj = 0;
21563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21564 int arg2 ;
21565 void *argp1 = 0 ;
21566 int res1 = 0 ;
21567 int val2 ;
21568 int ecode2 = 0 ;
21569 PyObject *swig_obj[2] ;
21570
21571 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21573 if (!SWIG_IsOK(res1)) {
21574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21575 }
21576 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21577 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21578 if (!SWIG_IsOK(ecode2)) {
21579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21580 }
21581 arg2 = static_cast< int >(val2);
21582 if (arg1) (arg1)->m_linesPerAction = arg2;
21583
21584 resultobj = SWIG_Py_Void();
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21592 PyObject *resultobj = 0;
21593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21594 int result;
21595 void *argp1 = 0 ;
21596 int res1 = 0 ;
21597 PyObject *swig_obj[1] ;
21598
21599 if (!args) SWIG_fail;
21600 swig_obj[0] = args;
21601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21602 if (!SWIG_IsOK(res1)) {
21603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21604 }
21605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21606 result = (int) ((arg1)->m_linesPerAction);
21607 resultobj = SWIG_From_int(static_cast< int >(result));
21608 return resultobj;
21609 fail:
21610 return NULL;
21611 }
21612
21613
21614 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21615 PyObject *obj;
21616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21617 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21618 return SWIG_Py_Void();
21619 }
21620
21621 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21622 return SWIG_Python_InitShadowInstance(args);
21623 }
21624
21625 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj = 0;
21627 int arg1 = (int) 0 ;
21628 int arg2 = (int) 0 ;
21629 wxSetCursorEvent *result = 0 ;
21630 int val1 ;
21631 int ecode1 = 0 ;
21632 int val2 ;
21633 int ecode2 = 0 ;
21634 PyObject * obj0 = 0 ;
21635 PyObject * obj1 = 0 ;
21636 char * kwnames[] = {
21637 (char *) "x",(char *) "y", NULL
21638 };
21639
21640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21641 if (obj0) {
21642 ecode1 = SWIG_AsVal_int(obj0, &val1);
21643 if (!SWIG_IsOK(ecode1)) {
21644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21645 }
21646 arg1 = static_cast< int >(val1);
21647 }
21648 if (obj1) {
21649 ecode2 = SWIG_AsVal_int(obj1, &val2);
21650 if (!SWIG_IsOK(ecode2)) {
21651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21652 }
21653 arg2 = static_cast< int >(val2);
21654 }
21655 {
21656 PyThreadState* __tstate = wxPyBeginAllowThreads();
21657 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21658 wxPyEndAllowThreads(__tstate);
21659 if (PyErr_Occurred()) SWIG_fail;
21660 }
21661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21662 return resultobj;
21663 fail:
21664 return NULL;
21665 }
21666
21667
21668 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21669 PyObject *resultobj = 0;
21670 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21671 int result;
21672 void *argp1 = 0 ;
21673 int res1 = 0 ;
21674 PyObject *swig_obj[1] ;
21675
21676 if (!args) SWIG_fail;
21677 swig_obj[0] = args;
21678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21679 if (!SWIG_IsOK(res1)) {
21680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21681 }
21682 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_From_int(static_cast< int >(result));
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21699 int result;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21709 }
21710 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 resultobj = SWIG_From_int(static_cast< int >(result));
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21725 PyObject *resultobj = 0;
21726 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21727 wxCursor *arg2 = 0 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 void *argp2 = 0 ;
21731 int res2 = 0 ;
21732 PyObject * obj0 = 0 ;
21733 PyObject * obj1 = 0 ;
21734 char * kwnames[] = {
21735 (char *) "self",(char *) "cursor", NULL
21736 };
21737
21738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21740 if (!SWIG_IsOK(res1)) {
21741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21742 }
21743 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21745 if (!SWIG_IsOK(res2)) {
21746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21747 }
21748 if (!argp2) {
21749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21750 }
21751 arg2 = reinterpret_cast< wxCursor * >(argp2);
21752 {
21753 PyThreadState* __tstate = wxPyBeginAllowThreads();
21754 (arg1)->SetCursor((wxCursor const &)*arg2);
21755 wxPyEndAllowThreads(__tstate);
21756 if (PyErr_Occurred()) SWIG_fail;
21757 }
21758 resultobj = SWIG_Py_Void();
21759 return resultobj;
21760 fail:
21761 return NULL;
21762 }
21763
21764
21765 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21766 PyObject *resultobj = 0;
21767 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21768 wxCursor *result = 0 ;
21769 void *argp1 = 0 ;
21770 int res1 = 0 ;
21771 PyObject *swig_obj[1] ;
21772
21773 if (!args) SWIG_fail;
21774 swig_obj[0] = args;
21775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21776 if (!SWIG_IsOK(res1)) {
21777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21778 }
21779 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21780 {
21781 PyThreadState* __tstate = wxPyBeginAllowThreads();
21782 {
21783 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21784 result = (wxCursor *) &_result_ref;
21785 }
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 {
21790 wxCursor* resultptr = new wxCursor(*result);
21791 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21792 }
21793 return resultobj;
21794 fail:
21795 return NULL;
21796 }
21797
21798
21799 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21800 PyObject *resultobj = 0;
21801 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21802 bool result;
21803 void *argp1 = 0 ;
21804 int res1 = 0 ;
21805 PyObject *swig_obj[1] ;
21806
21807 if (!args) SWIG_fail;
21808 swig_obj[0] = args;
21809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21810 if (!SWIG_IsOK(res1)) {
21811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21812 }
21813 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21814 {
21815 PyThreadState* __tstate = wxPyBeginAllowThreads();
21816 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21817 wxPyEndAllowThreads(__tstate);
21818 if (PyErr_Occurred()) SWIG_fail;
21819 }
21820 {
21821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21822 }
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21830 PyObject *obj;
21831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21832 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21833 return SWIG_Py_Void();
21834 }
21835
21836 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21837 return SWIG_Python_InitShadowInstance(args);
21838 }
21839
21840 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21841 PyObject *resultobj = 0;
21842 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21843 wxKeyEvent *result = 0 ;
21844 int val1 ;
21845 int ecode1 = 0 ;
21846 PyObject * obj0 = 0 ;
21847 char * kwnames[] = {
21848 (char *) "eventType", NULL
21849 };
21850
21851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21852 if (obj0) {
21853 ecode1 = SWIG_AsVal_int(obj0, &val1);
21854 if (!SWIG_IsOK(ecode1)) {
21855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21856 }
21857 arg1 = static_cast< wxEventType >(val1);
21858 }
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21862 wxPyEndAllowThreads(__tstate);
21863 if (PyErr_Occurred()) SWIG_fail;
21864 }
21865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21866 return resultobj;
21867 fail:
21868 return NULL;
21869 }
21870
21871
21872 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21873 PyObject *resultobj = 0;
21874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21875 int result;
21876 void *argp1 = 0 ;
21877 int res1 = 0 ;
21878 PyObject *swig_obj[1] ;
21879
21880 if (!args) SWIG_fail;
21881 swig_obj[0] = args;
21882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21883 if (!SWIG_IsOK(res1)) {
21884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21885 }
21886 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21887 {
21888 PyThreadState* __tstate = wxPyBeginAllowThreads();
21889 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21890 wxPyEndAllowThreads(__tstate);
21891 if (PyErr_Occurred()) SWIG_fail;
21892 }
21893 resultobj = SWIG_From_int(static_cast< int >(result));
21894 return resultobj;
21895 fail:
21896 return NULL;
21897 }
21898
21899
21900 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 PyObject *resultobj = 0;
21902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21903 bool result;
21904 void *argp1 = 0 ;
21905 int res1 = 0 ;
21906 PyObject *swig_obj[1] ;
21907
21908 if (!args) SWIG_fail;
21909 swig_obj[0] = args;
21910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21911 if (!SWIG_IsOK(res1)) {
21912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21913 }
21914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21918 wxPyEndAllowThreads(__tstate);
21919 if (PyErr_Occurred()) SWIG_fail;
21920 }
21921 {
21922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21923 }
21924 return resultobj;
21925 fail:
21926 return NULL;
21927 }
21928
21929
21930 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21931 PyObject *resultobj = 0;
21932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21933 bool result;
21934 void *argp1 = 0 ;
21935 int res1 = 0 ;
21936 PyObject *swig_obj[1] ;
21937
21938 if (!args) SWIG_fail;
21939 swig_obj[0] = args;
21940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21941 if (!SWIG_IsOK(res1)) {
21942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21943 }
21944 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21945 {
21946 PyThreadState* __tstate = wxPyBeginAllowThreads();
21947 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21948 wxPyEndAllowThreads(__tstate);
21949 if (PyErr_Occurred()) SWIG_fail;
21950 }
21951 {
21952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21953 }
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21961 PyObject *resultobj = 0;
21962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21963 bool result;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 PyObject *swig_obj[1] ;
21967
21968 if (!args) SWIG_fail;
21969 swig_obj[0] = args;
21970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21971 if (!SWIG_IsOK(res1)) {
21972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21973 }
21974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21975 {
21976 PyThreadState* __tstate = wxPyBeginAllowThreads();
21977 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21978 wxPyEndAllowThreads(__tstate);
21979 if (PyErr_Occurred()) SWIG_fail;
21980 }
21981 {
21982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21983 }
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21991 PyObject *resultobj = 0;
21992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21993 bool result;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 PyObject *swig_obj[1] ;
21997
21998 if (!args) SWIG_fail;
21999 swig_obj[0] = args;
22000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22003 }
22004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22005 {
22006 PyThreadState* __tstate = wxPyBeginAllowThreads();
22007 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22008 wxPyEndAllowThreads(__tstate);
22009 if (PyErr_Occurred()) SWIG_fail;
22010 }
22011 {
22012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22013 }
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22023 bool 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_wxKeyEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22033 }
22034 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 {
22042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22043 }
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22053 bool result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 {
22072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22073 }
22074 return resultobj;
22075 fail:
22076 return NULL;
22077 }
22078
22079
22080 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22081 PyObject *resultobj = 0;
22082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22083 int result;
22084 void *argp1 = 0 ;
22085 int res1 = 0 ;
22086 PyObject *swig_obj[1] ;
22087
22088 if (!args) SWIG_fail;
22089 swig_obj[0] = args;
22090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22091 if (!SWIG_IsOK(res1)) {
22092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22093 }
22094 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22095 {
22096 PyThreadState* __tstate = wxPyBeginAllowThreads();
22097 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22098 wxPyEndAllowThreads(__tstate);
22099 if (PyErr_Occurred()) SWIG_fail;
22100 }
22101 resultobj = SWIG_From_int(static_cast< int >(result));
22102 return resultobj;
22103 fail:
22104 return NULL;
22105 }
22106
22107
22108 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22109 PyObject *resultobj = 0;
22110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22111 int result;
22112 void *argp1 = 0 ;
22113 int res1 = 0 ;
22114 PyObject *swig_obj[1] ;
22115
22116 if (!args) SWIG_fail;
22117 swig_obj[0] = args;
22118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22119 if (!SWIG_IsOK(res1)) {
22120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22121 }
22122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_From_int(static_cast< int >(result));
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22139 unsigned int result;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22165 PyObject *resultobj = 0;
22166 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22167 unsigned int result;
22168 void *argp1 = 0 ;
22169 int res1 = 0 ;
22170 PyObject *swig_obj[1] ;
22171
22172 if (!args) SWIG_fail;
22173 swig_obj[0] = args;
22174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22175 if (!SWIG_IsOK(res1)) {
22176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22177 }
22178 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22193 PyObject *resultobj = 0;
22194 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22195 wxPoint result;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject *swig_obj[1] ;
22199
22200 if (!args) SWIG_fail;
22201 swig_obj[0] = args;
22202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22203 if (!SWIG_IsOK(res1)) {
22204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22205 }
22206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (arg1)->GetPosition();
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22223 long *arg2 = (long *) 0 ;
22224 long *arg3 = (long *) 0 ;
22225 void *argp1 = 0 ;
22226 int res1 = 0 ;
22227 long temp2 ;
22228 int res2 = SWIG_TMPOBJ ;
22229 long temp3 ;
22230 int res3 = SWIG_TMPOBJ ;
22231 PyObject *swig_obj[1] ;
22232
22233 arg2 = &temp2;
22234 arg3 = &temp3;
22235 if (!args) SWIG_fail;
22236 swig_obj[0] = args;
22237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22238 if (!SWIG_IsOK(res1)) {
22239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22240 }
22241 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22242 {
22243 PyThreadState* __tstate = wxPyBeginAllowThreads();
22244 (arg1)->GetPosition(arg2,arg3);
22245 wxPyEndAllowThreads(__tstate);
22246 if (PyErr_Occurred()) SWIG_fail;
22247 }
22248 resultobj = SWIG_Py_Void();
22249 if (SWIG_IsTmpObj(res2)) {
22250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22251 } else {
22252 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22254 }
22255 if (SWIG_IsTmpObj(res3)) {
22256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22257 } else {
22258 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22260 }
22261 return resultobj;
22262 fail:
22263 return NULL;
22264 }
22265
22266
22267 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22268 PyObject *resultobj = 0;
22269 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22270 int result;
22271 void *argp1 = 0 ;
22272 int res1 = 0 ;
22273 PyObject *swig_obj[1] ;
22274
22275 if (!args) SWIG_fail;
22276 swig_obj[0] = args;
22277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22278 if (!SWIG_IsOK(res1)) {
22279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22280 }
22281 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22282 {
22283 PyThreadState* __tstate = wxPyBeginAllowThreads();
22284 result = (int)((wxKeyEvent const *)arg1)->GetX();
22285 wxPyEndAllowThreads(__tstate);
22286 if (PyErr_Occurred()) SWIG_fail;
22287 }
22288 resultobj = SWIG_From_int(static_cast< int >(result));
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22296 PyObject *resultobj = 0;
22297 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22298 int result;
22299 void *argp1 = 0 ;
22300 int res1 = 0 ;
22301 PyObject *swig_obj[1] ;
22302
22303 if (!args) SWIG_fail;
22304 swig_obj[0] = args;
22305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22306 if (!SWIG_IsOK(res1)) {
22307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22308 }
22309 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 result = (int)((wxKeyEvent const *)arg1)->GetY();
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 resultobj = SWIG_From_int(static_cast< int >(result));
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22324 PyObject *resultobj = 0;
22325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22326 int arg2 ;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 int val2 ;
22330 int ecode2 = 0 ;
22331 PyObject *swig_obj[2] ;
22332
22333 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22335 if (!SWIG_IsOK(res1)) {
22336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22337 }
22338 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22339 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22340 if (!SWIG_IsOK(ecode2)) {
22341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22342 }
22343 arg2 = static_cast< int >(val2);
22344 if (arg1) (arg1)->m_x = arg2;
22345
22346 resultobj = SWIG_Py_Void();
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22354 PyObject *resultobj = 0;
22355 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22356 int result;
22357 void *argp1 = 0 ;
22358 int res1 = 0 ;
22359 PyObject *swig_obj[1] ;
22360
22361 if (!args) SWIG_fail;
22362 swig_obj[0] = args;
22363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22364 if (!SWIG_IsOK(res1)) {
22365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22366 }
22367 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22368 result = (int) ((arg1)->m_x);
22369 resultobj = SWIG_From_int(static_cast< int >(result));
22370 return resultobj;
22371 fail:
22372 return NULL;
22373 }
22374
22375
22376 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22377 PyObject *resultobj = 0;
22378 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22379 int arg2 ;
22380 void *argp1 = 0 ;
22381 int res1 = 0 ;
22382 int val2 ;
22383 int ecode2 = 0 ;
22384 PyObject *swig_obj[2] ;
22385
22386 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22388 if (!SWIG_IsOK(res1)) {
22389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22390 }
22391 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22392 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22393 if (!SWIG_IsOK(ecode2)) {
22394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22395 }
22396 arg2 = static_cast< int >(val2);
22397 if (arg1) (arg1)->m_y = arg2;
22398
22399 resultobj = SWIG_Py_Void();
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22409 int result;
22410 void *argp1 = 0 ;
22411 int res1 = 0 ;
22412 PyObject *swig_obj[1] ;
22413
22414 if (!args) SWIG_fail;
22415 swig_obj[0] = args;
22416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22417 if (!SWIG_IsOK(res1)) {
22418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22419 }
22420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22421 result = (int) ((arg1)->m_y);
22422 resultobj = SWIG_From_int(static_cast< int >(result));
22423 return resultobj;
22424 fail:
22425 return NULL;
22426 }
22427
22428
22429 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22430 PyObject *resultobj = 0;
22431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22432 long arg2 ;
22433 void *argp1 = 0 ;
22434 int res1 = 0 ;
22435 long val2 ;
22436 int ecode2 = 0 ;
22437 PyObject *swig_obj[2] ;
22438
22439 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22441 if (!SWIG_IsOK(res1)) {
22442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22443 }
22444 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22445 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22446 if (!SWIG_IsOK(ecode2)) {
22447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22448 }
22449 arg2 = static_cast< long >(val2);
22450 if (arg1) (arg1)->m_keyCode = arg2;
22451
22452 resultobj = SWIG_Py_Void();
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22460 PyObject *resultobj = 0;
22461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22462 long result;
22463 void *argp1 = 0 ;
22464 int res1 = 0 ;
22465 PyObject *swig_obj[1] ;
22466
22467 if (!args) SWIG_fail;
22468 swig_obj[0] = args;
22469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22470 if (!SWIG_IsOK(res1)) {
22471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22472 }
22473 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22474 result = (long) ((arg1)->m_keyCode);
22475 resultobj = SWIG_From_long(static_cast< long >(result));
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22483 PyObject *resultobj = 0;
22484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22485 bool arg2 ;
22486 void *argp1 = 0 ;
22487 int res1 = 0 ;
22488 bool val2 ;
22489 int ecode2 = 0 ;
22490 PyObject *swig_obj[2] ;
22491
22492 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22494 if (!SWIG_IsOK(res1)) {
22495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22496 }
22497 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22498 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22499 if (!SWIG_IsOK(ecode2)) {
22500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22501 }
22502 arg2 = static_cast< bool >(val2);
22503 if (arg1) (arg1)->m_controlDown = arg2;
22504
22505 resultobj = SWIG_Py_Void();
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *resultobj = 0;
22514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22515 bool result;
22516 void *argp1 = 0 ;
22517 int res1 = 0 ;
22518 PyObject *swig_obj[1] ;
22519
22520 if (!args) SWIG_fail;
22521 swig_obj[0] = args;
22522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22523 if (!SWIG_IsOK(res1)) {
22524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22525 }
22526 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22527 result = (bool) ((arg1)->m_controlDown);
22528 {
22529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22530 }
22531 return resultobj;
22532 fail:
22533 return NULL;
22534 }
22535
22536
22537 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22538 PyObject *resultobj = 0;
22539 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22540 bool arg2 ;
22541 void *argp1 = 0 ;
22542 int res1 = 0 ;
22543 bool val2 ;
22544 int ecode2 = 0 ;
22545 PyObject *swig_obj[2] ;
22546
22547 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22549 if (!SWIG_IsOK(res1)) {
22550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22551 }
22552 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22553 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22554 if (!SWIG_IsOK(ecode2)) {
22555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22556 }
22557 arg2 = static_cast< bool >(val2);
22558 if (arg1) (arg1)->m_shiftDown = arg2;
22559
22560 resultobj = SWIG_Py_Void();
22561 return resultobj;
22562 fail:
22563 return NULL;
22564 }
22565
22566
22567 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22568 PyObject *resultobj = 0;
22569 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22570 bool result;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 PyObject *swig_obj[1] ;
22574
22575 if (!args) SWIG_fail;
22576 swig_obj[0] = args;
22577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22578 if (!SWIG_IsOK(res1)) {
22579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22580 }
22581 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22582 result = (bool) ((arg1)->m_shiftDown);
22583 {
22584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22585 }
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22593 PyObject *resultobj = 0;
22594 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22595 bool arg2 ;
22596 void *argp1 = 0 ;
22597 int res1 = 0 ;
22598 bool val2 ;
22599 int ecode2 = 0 ;
22600 PyObject *swig_obj[2] ;
22601
22602 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22604 if (!SWIG_IsOK(res1)) {
22605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22606 }
22607 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22608 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22609 if (!SWIG_IsOK(ecode2)) {
22610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22611 }
22612 arg2 = static_cast< bool >(val2);
22613 if (arg1) (arg1)->m_altDown = arg2;
22614
22615 resultobj = SWIG_Py_Void();
22616 return resultobj;
22617 fail:
22618 return NULL;
22619 }
22620
22621
22622 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22623 PyObject *resultobj = 0;
22624 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22625 bool result;
22626 void *argp1 = 0 ;
22627 int res1 = 0 ;
22628 PyObject *swig_obj[1] ;
22629
22630 if (!args) SWIG_fail;
22631 swig_obj[0] = args;
22632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22633 if (!SWIG_IsOK(res1)) {
22634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22635 }
22636 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22637 result = (bool) ((arg1)->m_altDown);
22638 {
22639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22640 }
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22650 bool arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 bool val2 ;
22654 int ecode2 = 0 ;
22655 PyObject *swig_obj[2] ;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22661 }
22662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22663 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22666 }
22667 arg2 = static_cast< bool >(val2);
22668 if (arg1) (arg1)->m_metaDown = arg2;
22669
22670 resultobj = SWIG_Py_Void();
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 bool result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22692 result = (bool) ((arg1)->m_metaDown);
22693 {
22694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22695 }
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22705 bool arg2 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 bool val2 ;
22709 int ecode2 = 0 ;
22710 PyObject *swig_obj[2] ;
22711
22712 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22716 }
22717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22718 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22719 if (!SWIG_IsOK(ecode2)) {
22720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22721 }
22722 arg2 = static_cast< bool >(val2);
22723 if (arg1) (arg1)->m_scanCode = arg2;
22724
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 bool result;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 PyObject *swig_obj[1] ;
22739
22740 if (!args) SWIG_fail;
22741 swig_obj[0] = args;
22742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22745 }
22746 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22747 result = (bool) ((arg1)->m_scanCode);
22748 {
22749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22758 PyObject *resultobj = 0;
22759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22760 unsigned int arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 unsigned int val2 ;
22764 int ecode2 = 0 ;
22765 PyObject *swig_obj[2] ;
22766
22767 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22771 }
22772 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22773 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22774 if (!SWIG_IsOK(ecode2)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22776 }
22777 arg2 = static_cast< unsigned int >(val2);
22778 if (arg1) (arg1)->m_rawCode = arg2;
22779
22780 resultobj = SWIG_Py_Void();
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 PyObject *resultobj = 0;
22789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22790 unsigned int result;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 PyObject *swig_obj[1] ;
22794
22795 if (!args) SWIG_fail;
22796 swig_obj[0] = args;
22797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22798 if (!SWIG_IsOK(res1)) {
22799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22800 }
22801 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22802 result = (unsigned int) ((arg1)->m_rawCode);
22803 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22804 return resultobj;
22805 fail:
22806 return NULL;
22807 }
22808
22809
22810 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22811 PyObject *resultobj = 0;
22812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22813 unsigned int arg2 ;
22814 void *argp1 = 0 ;
22815 int res1 = 0 ;
22816 unsigned int val2 ;
22817 int ecode2 = 0 ;
22818 PyObject *swig_obj[2] ;
22819
22820 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22822 if (!SWIG_IsOK(res1)) {
22823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22824 }
22825 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22826 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22827 if (!SWIG_IsOK(ecode2)) {
22828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22829 }
22830 arg2 = static_cast< unsigned int >(val2);
22831 if (arg1) (arg1)->m_rawFlags = arg2;
22832
22833 resultobj = SWIG_Py_Void();
22834 return resultobj;
22835 fail:
22836 return NULL;
22837 }
22838
22839
22840 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22841 PyObject *resultobj = 0;
22842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22843 unsigned int result;
22844 void *argp1 = 0 ;
22845 int res1 = 0 ;
22846 PyObject *swig_obj[1] ;
22847
22848 if (!args) SWIG_fail;
22849 swig_obj[0] = args;
22850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22851 if (!SWIG_IsOK(res1)) {
22852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22853 }
22854 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22855 result = (unsigned int) ((arg1)->m_rawFlags);
22856 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22864 PyObject *obj;
22865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22866 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22867 return SWIG_Py_Void();
22868 }
22869
22870 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 return SWIG_Python_InitShadowInstance(args);
22872 }
22873
22874 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj = 0;
22876 wxSize const &arg1_defvalue = wxDefaultSize ;
22877 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22878 int arg2 = (int) 0 ;
22879 wxSizeEvent *result = 0 ;
22880 wxSize temp1 ;
22881 int val2 ;
22882 int ecode2 = 0 ;
22883 PyObject * obj0 = 0 ;
22884 PyObject * obj1 = 0 ;
22885 char * kwnames[] = {
22886 (char *) "sz",(char *) "winid", NULL
22887 };
22888
22889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22890 if (obj0) {
22891 {
22892 arg1 = &temp1;
22893 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22894 }
22895 }
22896 if (obj1) {
22897 ecode2 = SWIG_AsVal_int(obj1, &val2);
22898 if (!SWIG_IsOK(ecode2)) {
22899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22900 }
22901 arg2 = static_cast< int >(val2);
22902 }
22903 {
22904 PyThreadState* __tstate = wxPyBeginAllowThreads();
22905 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22906 wxPyEndAllowThreads(__tstate);
22907 if (PyErr_Occurred()) SWIG_fail;
22908 }
22909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22910 return resultobj;
22911 fail:
22912 return NULL;
22913 }
22914
22915
22916 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22917 PyObject *resultobj = 0;
22918 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22919 wxSize result;
22920 void *argp1 = 0 ;
22921 int res1 = 0 ;
22922 PyObject *swig_obj[1] ;
22923
22924 if (!args) SWIG_fail;
22925 swig_obj[0] = args;
22926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22927 if (!SWIG_IsOK(res1)) {
22928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22929 }
22930 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22931 {
22932 PyThreadState* __tstate = wxPyBeginAllowThreads();
22933 result = ((wxSizeEvent const *)arg1)->GetSize();
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22938 return resultobj;
22939 fail:
22940 return NULL;
22941 }
22942
22943
22944 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22945 PyObject *resultobj = 0;
22946 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22947 wxRect result;
22948 void *argp1 = 0 ;
22949 int res1 = 0 ;
22950 PyObject *swig_obj[1] ;
22951
22952 if (!args) SWIG_fail;
22953 swig_obj[0] = args;
22954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22955 if (!SWIG_IsOK(res1)) {
22956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22957 }
22958 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 result = ((wxSizeEvent const *)arg1)->GetRect();
22962 wxPyEndAllowThreads(__tstate);
22963 if (PyErr_Occurred()) SWIG_fail;
22964 }
22965 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22966 return resultobj;
22967 fail:
22968 return NULL;
22969 }
22970
22971
22972 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22973 PyObject *resultobj = 0;
22974 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22975 wxRect arg2 ;
22976 void *argp1 = 0 ;
22977 int res1 = 0 ;
22978 void *argp2 ;
22979 int res2 = 0 ;
22980 PyObject * obj0 = 0 ;
22981 PyObject * obj1 = 0 ;
22982 char * kwnames[] = {
22983 (char *) "self",(char *) "rect", NULL
22984 };
22985
22986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22988 if (!SWIG_IsOK(res1)) {
22989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22990 }
22991 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22992 {
22993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22994 if (!SWIG_IsOK(res2)) {
22995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22996 }
22997 if (!argp2) {
22998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22999 } else {
23000 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23001 arg2 = *temp;
23002 if (SWIG_IsNewObj(res2)) delete temp;
23003 }
23004 }
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 (arg1)->SetRect(arg2);
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 resultobj = SWIG_Py_Void();
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23019 PyObject *resultobj = 0;
23020 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23021 wxSize arg2 ;
23022 void *argp1 = 0 ;
23023 int res1 = 0 ;
23024 void *argp2 ;
23025 int res2 = 0 ;
23026 PyObject * obj0 = 0 ;
23027 PyObject * obj1 = 0 ;
23028 char * kwnames[] = {
23029 (char *) "self",(char *) "size", NULL
23030 };
23031
23032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23034 if (!SWIG_IsOK(res1)) {
23035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23036 }
23037 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23038 {
23039 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23040 if (!SWIG_IsOK(res2)) {
23041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23042 }
23043 if (!argp2) {
23044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23045 } else {
23046 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23047 arg2 = *temp;
23048 if (SWIG_IsNewObj(res2)) delete temp;
23049 }
23050 }
23051 {
23052 PyThreadState* __tstate = wxPyBeginAllowThreads();
23053 wxSizeEvent_SetSize(arg1,arg2);
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 resultobj = SWIG_Py_Void();
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23067 wxSize *arg2 = (wxSize *) 0 ;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 void *argp2 = 0 ;
23071 int res2 = 0 ;
23072 PyObject *swig_obj[2] ;
23073
23074 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23081 if (!SWIG_IsOK(res2)) {
23082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23083 }
23084 arg2 = reinterpret_cast< wxSize * >(argp2);
23085 if (arg1) (arg1)->m_size = *arg2;
23086
23087 resultobj = SWIG_Py_Void();
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23097 wxSize *result = 0 ;
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_wxSizeEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23109 result = (wxSize *)& ((arg1)->m_size);
23110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23111 return resultobj;
23112 fail:
23113 return NULL;
23114 }
23115
23116
23117 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23118 PyObject *resultobj = 0;
23119 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23120 wxRect *arg2 = (wxRect *) 0 ;
23121 void *argp1 = 0 ;
23122 int res1 = 0 ;
23123 void *argp2 = 0 ;
23124 int res2 = 0 ;
23125 PyObject *swig_obj[2] ;
23126
23127 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23129 if (!SWIG_IsOK(res1)) {
23130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23131 }
23132 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23133 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23134 if (!SWIG_IsOK(res2)) {
23135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23136 }
23137 arg2 = reinterpret_cast< wxRect * >(argp2);
23138 if (arg1) (arg1)->m_rect = *arg2;
23139
23140 resultobj = SWIG_Py_Void();
23141 return resultobj;
23142 fail:
23143 return NULL;
23144 }
23145
23146
23147 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23148 PyObject *resultobj = 0;
23149 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23150 wxRect *result = 0 ;
23151 void *argp1 = 0 ;
23152 int res1 = 0 ;
23153 PyObject *swig_obj[1] ;
23154
23155 if (!args) SWIG_fail;
23156 swig_obj[0] = args;
23157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23158 if (!SWIG_IsOK(res1)) {
23159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23160 }
23161 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23162 result = (wxRect *)& ((arg1)->m_rect);
23163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23164 return resultobj;
23165 fail:
23166 return NULL;
23167 }
23168
23169
23170 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23171 PyObject *obj;
23172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23173 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23174 return SWIG_Py_Void();
23175 }
23176
23177 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23178 return SWIG_Python_InitShadowInstance(args);
23179 }
23180
23181 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23182 PyObject *resultobj = 0;
23183 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23184 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23185 int arg2 = (int) 0 ;
23186 wxMoveEvent *result = 0 ;
23187 wxPoint temp1 ;
23188 int val2 ;
23189 int ecode2 = 0 ;
23190 PyObject * obj0 = 0 ;
23191 PyObject * obj1 = 0 ;
23192 char * kwnames[] = {
23193 (char *) "pos",(char *) "winid", NULL
23194 };
23195
23196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23197 if (obj0) {
23198 {
23199 arg1 = &temp1;
23200 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23201 }
23202 }
23203 if (obj1) {
23204 ecode2 = SWIG_AsVal_int(obj1, &val2);
23205 if (!SWIG_IsOK(ecode2)) {
23206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23207 }
23208 arg2 = static_cast< int >(val2);
23209 }
23210 {
23211 PyThreadState* __tstate = wxPyBeginAllowThreads();
23212 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23213 wxPyEndAllowThreads(__tstate);
23214 if (PyErr_Occurred()) SWIG_fail;
23215 }
23216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23217 return resultobj;
23218 fail:
23219 return NULL;
23220 }
23221
23222
23223 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23224 PyObject *resultobj = 0;
23225 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23226 wxPoint result;
23227 void *argp1 = 0 ;
23228 int res1 = 0 ;
23229 PyObject *swig_obj[1] ;
23230
23231 if (!args) SWIG_fail;
23232 swig_obj[0] = args;
23233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23234 if (!SWIG_IsOK(res1)) {
23235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23236 }
23237 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = ((wxMoveEvent const *)arg1)->GetPosition();
23241 wxPyEndAllowThreads(__tstate);
23242 if (PyErr_Occurred()) SWIG_fail;
23243 }
23244 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23252 PyObject *resultobj = 0;
23253 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23254 wxRect result;
23255 void *argp1 = 0 ;
23256 int res1 = 0 ;
23257 PyObject *swig_obj[1] ;
23258
23259 if (!args) SWIG_fail;
23260 swig_obj[0] = args;
23261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23262 if (!SWIG_IsOK(res1)) {
23263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23264 }
23265 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 result = ((wxMoveEvent const *)arg1)->GetRect();
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj = 0;
23281 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23282 wxRect *arg2 = 0 ;
23283 void *argp1 = 0 ;
23284 int res1 = 0 ;
23285 wxRect temp2 ;
23286 PyObject * obj0 = 0 ;
23287 PyObject * obj1 = 0 ;
23288 char * kwnames[] = {
23289 (char *) "self",(char *) "rect", NULL
23290 };
23291
23292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23294 if (!SWIG_IsOK(res1)) {
23295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23296 }
23297 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23298 {
23299 arg2 = &temp2;
23300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23301 }
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 (arg1)->SetRect((wxRect const &)*arg2);
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 resultobj = SWIG_Py_Void();
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23316 PyObject *resultobj = 0;
23317 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23318 wxPoint *arg2 = 0 ;
23319 void *argp1 = 0 ;
23320 int res1 = 0 ;
23321 wxPoint temp2 ;
23322 PyObject * obj0 = 0 ;
23323 PyObject * obj1 = 0 ;
23324 char * kwnames[] = {
23325 (char *) "self",(char *) "pos", NULL
23326 };
23327
23328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23330 if (!SWIG_IsOK(res1)) {
23331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23332 }
23333 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23334 {
23335 arg2 = &temp2;
23336 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23337 }
23338 {
23339 PyThreadState* __tstate = wxPyBeginAllowThreads();
23340 (arg1)->SetPosition((wxPoint const &)*arg2);
23341 wxPyEndAllowThreads(__tstate);
23342 if (PyErr_Occurred()) SWIG_fail;
23343 }
23344 resultobj = SWIG_Py_Void();
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *obj;
23353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23354 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23355 return SWIG_Py_Void();
23356 }
23357
23358 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23359 return SWIG_Python_InitShadowInstance(args);
23360 }
23361
23362 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23363 PyObject *resultobj = 0;
23364 int arg1 = (int) 0 ;
23365 wxPaintEvent *result = 0 ;
23366 int val1 ;
23367 int ecode1 = 0 ;
23368 PyObject * obj0 = 0 ;
23369 char * kwnames[] = {
23370 (char *) "Id", NULL
23371 };
23372
23373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23374 if (obj0) {
23375 ecode1 = SWIG_AsVal_int(obj0, &val1);
23376 if (!SWIG_IsOK(ecode1)) {
23377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23378 }
23379 arg1 = static_cast< int >(val1);
23380 }
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23384 wxPyEndAllowThreads(__tstate);
23385 if (PyErr_Occurred()) SWIG_fail;
23386 }
23387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23395 PyObject *obj;
23396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23397 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23398 return SWIG_Py_Void();
23399 }
23400
23401 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23402 return SWIG_Python_InitShadowInstance(args);
23403 }
23404
23405 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj = 0;
23407 int arg1 = (int) 0 ;
23408 wxNcPaintEvent *result = 0 ;
23409 int val1 ;
23410 int ecode1 = 0 ;
23411 PyObject * obj0 = 0 ;
23412 char * kwnames[] = {
23413 (char *) "winid", NULL
23414 };
23415
23416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23417 if (obj0) {
23418 ecode1 = SWIG_AsVal_int(obj0, &val1);
23419 if (!SWIG_IsOK(ecode1)) {
23420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23421 }
23422 arg1 = static_cast< int >(val1);
23423 }
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *obj;
23439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23440 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23441 return SWIG_Py_Void();
23442 }
23443
23444 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23445 return SWIG_Python_InitShadowInstance(args);
23446 }
23447
23448 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj = 0;
23450 int arg1 = (int) 0 ;
23451 wxDC *arg2 = (wxDC *) NULL ;
23452 wxEraseEvent *result = 0 ;
23453 int val1 ;
23454 int ecode1 = 0 ;
23455 void *argp2 = 0 ;
23456 int res2 = 0 ;
23457 PyObject * obj0 = 0 ;
23458 PyObject * obj1 = 0 ;
23459 char * kwnames[] = {
23460 (char *) "Id",(char *) "dc", NULL
23461 };
23462
23463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23464 if (obj0) {
23465 ecode1 = SWIG_AsVal_int(obj0, &val1);
23466 if (!SWIG_IsOK(ecode1)) {
23467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23468 }
23469 arg1 = static_cast< int >(val1);
23470 }
23471 if (obj1) {
23472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23473 if (!SWIG_IsOK(res2)) {
23474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23475 }
23476 arg2 = reinterpret_cast< wxDC * >(argp2);
23477 }
23478 {
23479 PyThreadState* __tstate = wxPyBeginAllowThreads();
23480 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23481 wxPyEndAllowThreads(__tstate);
23482 if (PyErr_Occurred()) SWIG_fail;
23483 }
23484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23485 return resultobj;
23486 fail:
23487 return NULL;
23488 }
23489
23490
23491 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23492 PyObject *resultobj = 0;
23493 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23494 wxDC *result = 0 ;
23495 void *argp1 = 0 ;
23496 int res1 = 0 ;
23497 PyObject *swig_obj[1] ;
23498
23499 if (!args) SWIG_fail;
23500 swig_obj[0] = args;
23501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23502 if (!SWIG_IsOK(res1)) {
23503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23504 }
23505 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 {
23513 resultobj = wxPyMake_wxObject(result, (bool)0);
23514 }
23515 return resultobj;
23516 fail:
23517 return NULL;
23518 }
23519
23520
23521 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23522 PyObject *obj;
23523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23524 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23525 return SWIG_Py_Void();
23526 }
23527
23528 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23529 return SWIG_Python_InitShadowInstance(args);
23530 }
23531
23532 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23533 PyObject *resultobj = 0;
23534 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23535 int arg2 = (int) 0 ;
23536 wxFocusEvent *result = 0 ;
23537 int val1 ;
23538 int ecode1 = 0 ;
23539 int val2 ;
23540 int ecode2 = 0 ;
23541 PyObject * obj0 = 0 ;
23542 PyObject * obj1 = 0 ;
23543 char * kwnames[] = {
23544 (char *) "type",(char *) "winid", NULL
23545 };
23546
23547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23548 if (obj0) {
23549 ecode1 = SWIG_AsVal_int(obj0, &val1);
23550 if (!SWIG_IsOK(ecode1)) {
23551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23552 }
23553 arg1 = static_cast< wxEventType >(val1);
23554 }
23555 if (obj1) {
23556 ecode2 = SWIG_AsVal_int(obj1, &val2);
23557 if (!SWIG_IsOK(ecode2)) {
23558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23559 }
23560 arg2 = static_cast< int >(val2);
23561 }
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23576 PyObject *resultobj = 0;
23577 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23578 wxWindow *result = 0 ;
23579 void *argp1 = 0 ;
23580 int res1 = 0 ;
23581 PyObject *swig_obj[1] ;
23582
23583 if (!args) SWIG_fail;
23584 swig_obj[0] = args;
23585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23586 if (!SWIG_IsOK(res1)) {
23587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23588 }
23589 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23590 {
23591 PyThreadState* __tstate = wxPyBeginAllowThreads();
23592 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23593 wxPyEndAllowThreads(__tstate);
23594 if (PyErr_Occurred()) SWIG_fail;
23595 }
23596 {
23597 resultobj = wxPyMake_wxObject(result, (bool)0);
23598 }
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23606 PyObject *resultobj = 0;
23607 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23608 wxWindow *arg2 = (wxWindow *) 0 ;
23609 void *argp1 = 0 ;
23610 int res1 = 0 ;
23611 void *argp2 = 0 ;
23612 int res2 = 0 ;
23613 PyObject * obj0 = 0 ;
23614 PyObject * obj1 = 0 ;
23615 char * kwnames[] = {
23616 (char *) "self",(char *) "win", NULL
23617 };
23618
23619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23621 if (!SWIG_IsOK(res1)) {
23622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23623 }
23624 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23626 if (!SWIG_IsOK(res2)) {
23627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23628 }
23629 arg2 = reinterpret_cast< wxWindow * >(argp2);
23630 {
23631 PyThreadState* __tstate = wxPyBeginAllowThreads();
23632 (arg1)->SetWindow(arg2);
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 resultobj = SWIG_Py_Void();
23637 return resultobj;
23638 fail:
23639 return NULL;
23640 }
23641
23642
23643 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23644 PyObject *obj;
23645 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23646 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23647 return SWIG_Py_Void();
23648 }
23649
23650 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23651 return SWIG_Python_InitShadowInstance(args);
23652 }
23653
23654 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23655 PyObject *resultobj = 0;
23656 wxWindow *arg1 = (wxWindow *) NULL ;
23657 wxChildFocusEvent *result = 0 ;
23658 void *argp1 = 0 ;
23659 int res1 = 0 ;
23660 PyObject * obj0 = 0 ;
23661 char * kwnames[] = {
23662 (char *) "win", NULL
23663 };
23664
23665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23666 if (obj0) {
23667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23668 if (!SWIG_IsOK(res1)) {
23669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23670 }
23671 arg1 = reinterpret_cast< wxWindow * >(argp1);
23672 }
23673 {
23674 PyThreadState* __tstate = wxPyBeginAllowThreads();
23675 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *resultobj = 0;
23688 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23689 wxWindow *result = 0 ;
23690 void *argp1 = 0 ;
23691 int res1 = 0 ;
23692 PyObject *swig_obj[1] ;
23693
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23699 }
23700 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 {
23708 resultobj = wxPyMake_wxObject(result, (bool)0);
23709 }
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23717 PyObject *obj;
23718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23719 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23720 return SWIG_Py_Void();
23721 }
23722
23723 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 return SWIG_Python_InitShadowInstance(args);
23725 }
23726
23727 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj = 0;
23729 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23730 bool arg2 = (bool) true ;
23731 int arg3 = (int) 0 ;
23732 wxActivateEvent *result = 0 ;
23733 int val1 ;
23734 int ecode1 = 0 ;
23735 bool val2 ;
23736 int ecode2 = 0 ;
23737 int val3 ;
23738 int ecode3 = 0 ;
23739 PyObject * obj0 = 0 ;
23740 PyObject * obj1 = 0 ;
23741 PyObject * obj2 = 0 ;
23742 char * kwnames[] = {
23743 (char *) "type",(char *) "active",(char *) "Id", NULL
23744 };
23745
23746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23747 if (obj0) {
23748 ecode1 = SWIG_AsVal_int(obj0, &val1);
23749 if (!SWIG_IsOK(ecode1)) {
23750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23751 }
23752 arg1 = static_cast< wxEventType >(val1);
23753 }
23754 if (obj1) {
23755 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23756 if (!SWIG_IsOK(ecode2)) {
23757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23758 }
23759 arg2 = static_cast< bool >(val2);
23760 }
23761 if (obj2) {
23762 ecode3 = SWIG_AsVal_int(obj2, &val3);
23763 if (!SWIG_IsOK(ecode3)) {
23764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23765 }
23766 arg3 = static_cast< int >(val3);
23767 }
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 PyObject *resultobj = 0;
23783 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23784 bool result;
23785 void *argp1 = 0 ;
23786 int res1 = 0 ;
23787 PyObject *swig_obj[1] ;
23788
23789 if (!args) SWIG_fail;
23790 swig_obj[0] = args;
23791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23792 if (!SWIG_IsOK(res1)) {
23793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23794 }
23795 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 {
23803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23804 }
23805 return resultobj;
23806 fail:
23807 return NULL;
23808 }
23809
23810
23811 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23812 PyObject *obj;
23813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23814 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23815 return SWIG_Py_Void();
23816 }
23817
23818 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23819 return SWIG_Python_InitShadowInstance(args);
23820 }
23821
23822 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj = 0;
23824 int arg1 = (int) 0 ;
23825 wxInitDialogEvent *result = 0 ;
23826 int val1 ;
23827 int ecode1 = 0 ;
23828 PyObject * obj0 = 0 ;
23829 char * kwnames[] = {
23830 (char *) "Id", NULL
23831 };
23832
23833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23834 if (obj0) {
23835 ecode1 = SWIG_AsVal_int(obj0, &val1);
23836 if (!SWIG_IsOK(ecode1)) {
23837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23838 }
23839 arg1 = static_cast< int >(val1);
23840 }
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23844 wxPyEndAllowThreads(__tstate);
23845 if (PyErr_Occurred()) SWIG_fail;
23846 }
23847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23855 PyObject *obj;
23856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23857 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23858 return SWIG_Py_Void();
23859 }
23860
23861 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23862 return SWIG_Python_InitShadowInstance(args);
23863 }
23864
23865 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23866 PyObject *resultobj = 0;
23867 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23868 int arg2 = (int) 0 ;
23869 wxMenu *arg3 = (wxMenu *) NULL ;
23870 wxMenuEvent *result = 0 ;
23871 int val1 ;
23872 int ecode1 = 0 ;
23873 int val2 ;
23874 int ecode2 = 0 ;
23875 void *argp3 = 0 ;
23876 int res3 = 0 ;
23877 PyObject * obj0 = 0 ;
23878 PyObject * obj1 = 0 ;
23879 PyObject * obj2 = 0 ;
23880 char * kwnames[] = {
23881 (char *) "type",(char *) "winid",(char *) "menu", NULL
23882 };
23883
23884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23885 if (obj0) {
23886 ecode1 = SWIG_AsVal_int(obj0, &val1);
23887 if (!SWIG_IsOK(ecode1)) {
23888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23889 }
23890 arg1 = static_cast< wxEventType >(val1);
23891 }
23892 if (obj1) {
23893 ecode2 = SWIG_AsVal_int(obj1, &val2);
23894 if (!SWIG_IsOK(ecode2)) {
23895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23896 }
23897 arg2 = static_cast< int >(val2);
23898 }
23899 if (obj2) {
23900 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23901 if (!SWIG_IsOK(res3)) {
23902 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23903 }
23904 arg3 = reinterpret_cast< wxMenu * >(argp3);
23905 }
23906 {
23907 PyThreadState* __tstate = wxPyBeginAllowThreads();
23908 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23909 wxPyEndAllowThreads(__tstate);
23910 if (PyErr_Occurred()) SWIG_fail;
23911 }
23912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 PyObject *resultobj = 0;
23921 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23922 int result;
23923 void *argp1 = 0 ;
23924 int res1 = 0 ;
23925 PyObject *swig_obj[1] ;
23926
23927 if (!args) SWIG_fail;
23928 swig_obj[0] = args;
23929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23930 if (!SWIG_IsOK(res1)) {
23931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23932 }
23933 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 resultobj = SWIG_From_int(static_cast< int >(result));
23941 return resultobj;
23942 fail:
23943 return NULL;
23944 }
23945
23946
23947 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23948 PyObject *resultobj = 0;
23949 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23950 bool result;
23951 void *argp1 = 0 ;
23952 int res1 = 0 ;
23953 PyObject *swig_obj[1] ;
23954
23955 if (!args) SWIG_fail;
23956 swig_obj[0] = args;
23957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23958 if (!SWIG_IsOK(res1)) {
23959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23960 }
23961 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23978 PyObject *resultobj = 0;
23979 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23980 wxMenu *result = 0 ;
23981 void *argp1 = 0 ;
23982 int res1 = 0 ;
23983 PyObject *swig_obj[1] ;
23984
23985 if (!args) SWIG_fail;
23986 swig_obj[0] = args;
23987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23988 if (!SWIG_IsOK(res1)) {
23989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23990 }
23991 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 {
23999 resultobj = wxPyMake_wxObject(result, (bool)0);
24000 }
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *obj;
24009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24010 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24011 return SWIG_Py_Void();
24012 }
24013
24014 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24015 return SWIG_Python_InitShadowInstance(args);
24016 }
24017
24018 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24019 PyObject *resultobj = 0;
24020 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24021 int arg2 = (int) 0 ;
24022 wxCloseEvent *result = 0 ;
24023 int val1 ;
24024 int ecode1 = 0 ;
24025 int val2 ;
24026 int ecode2 = 0 ;
24027 PyObject * obj0 = 0 ;
24028 PyObject * obj1 = 0 ;
24029 char * kwnames[] = {
24030 (char *) "type",(char *) "winid", NULL
24031 };
24032
24033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24034 if (obj0) {
24035 ecode1 = SWIG_AsVal_int(obj0, &val1);
24036 if (!SWIG_IsOK(ecode1)) {
24037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24038 }
24039 arg1 = static_cast< wxEventType >(val1);
24040 }
24041 if (obj1) {
24042 ecode2 = SWIG_AsVal_int(obj1, &val2);
24043 if (!SWIG_IsOK(ecode2)) {
24044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24045 }
24046 arg2 = static_cast< int >(val2);
24047 }
24048 {
24049 PyThreadState* __tstate = wxPyBeginAllowThreads();
24050 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24051 wxPyEndAllowThreads(__tstate);
24052 if (PyErr_Occurred()) SWIG_fail;
24053 }
24054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj = 0;
24063 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24064 bool arg2 ;
24065 void *argp1 = 0 ;
24066 int res1 = 0 ;
24067 bool val2 ;
24068 int ecode2 = 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char * kwnames[] = {
24072 (char *) "self",(char *) "logOff", NULL
24073 };
24074
24075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24077 if (!SWIG_IsOK(res1)) {
24078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24079 }
24080 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24081 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24082 if (!SWIG_IsOK(ecode2)) {
24083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24084 }
24085 arg2 = static_cast< bool >(val2);
24086 {
24087 PyThreadState* __tstate = wxPyBeginAllowThreads();
24088 (arg1)->SetLoggingOff(arg2);
24089 wxPyEndAllowThreads(__tstate);
24090 if (PyErr_Occurred()) SWIG_fail;
24091 }
24092 resultobj = SWIG_Py_Void();
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 PyObject *resultobj = 0;
24101 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24102 bool result;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 PyObject *swig_obj[1] ;
24106
24107 if (!args) SWIG_fail;
24108 swig_obj[0] = args;
24109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24110 if (!SWIG_IsOK(res1)) {
24111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24112 }
24113 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24114 {
24115 PyThreadState* __tstate = wxPyBeginAllowThreads();
24116 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24117 wxPyEndAllowThreads(__tstate);
24118 if (PyErr_Occurred()) SWIG_fail;
24119 }
24120 {
24121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24122 }
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24130 PyObject *resultobj = 0;
24131 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24132 bool arg2 = (bool) true ;
24133 void *argp1 = 0 ;
24134 int res1 = 0 ;
24135 bool val2 ;
24136 int ecode2 = 0 ;
24137 PyObject * obj0 = 0 ;
24138 PyObject * obj1 = 0 ;
24139 char * kwnames[] = {
24140 (char *) "self",(char *) "veto", NULL
24141 };
24142
24143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24145 if (!SWIG_IsOK(res1)) {
24146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24147 }
24148 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24149 if (obj1) {
24150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24151 if (!SWIG_IsOK(ecode2)) {
24152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24153 }
24154 arg2 = static_cast< bool >(val2);
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 (arg1)->Veto(arg2);
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 resultobj = SWIG_Py_Void();
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *resultobj = 0;
24171 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24172 bool result;
24173 void *argp1 = 0 ;
24174 int res1 = 0 ;
24175 PyObject *swig_obj[1] ;
24176
24177 if (!args) SWIG_fail;
24178 swig_obj[0] = args;
24179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24180 if (!SWIG_IsOK(res1)) {
24181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24182 }
24183 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24184 {
24185 PyThreadState* __tstate = wxPyBeginAllowThreads();
24186 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24187 wxPyEndAllowThreads(__tstate);
24188 if (PyErr_Occurred()) SWIG_fail;
24189 }
24190 {
24191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24192 }
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24200 PyObject *resultobj = 0;
24201 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24202 bool arg2 ;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 bool val2 ;
24206 int ecode2 = 0 ;
24207 PyObject * obj0 = 0 ;
24208 PyObject * obj1 = 0 ;
24209 char * kwnames[] = {
24210 (char *) "self",(char *) "canVeto", NULL
24211 };
24212
24213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24215 if (!SWIG_IsOK(res1)) {
24216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24217 }
24218 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24219 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24220 if (!SWIG_IsOK(ecode2)) {
24221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24222 }
24223 arg2 = static_cast< bool >(val2);
24224 {
24225 PyThreadState* __tstate = wxPyBeginAllowThreads();
24226 (arg1)->SetCanVeto(arg2);
24227 wxPyEndAllowThreads(__tstate);
24228 if (PyErr_Occurred()) SWIG_fail;
24229 }
24230 resultobj = SWIG_Py_Void();
24231 return resultobj;
24232 fail:
24233 return NULL;
24234 }
24235
24236
24237 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24238 PyObject *resultobj = 0;
24239 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24240 bool result;
24241 void *argp1 = 0 ;
24242 int res1 = 0 ;
24243 PyObject *swig_obj[1] ;
24244
24245 if (!args) SWIG_fail;
24246 swig_obj[0] = args;
24247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24248 if (!SWIG_IsOK(res1)) {
24249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24250 }
24251 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 {
24259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24260 }
24261 return resultobj;
24262 fail:
24263 return NULL;
24264 }
24265
24266
24267 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24268 PyObject *obj;
24269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24270 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24271 return SWIG_Py_Void();
24272 }
24273
24274 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24275 return SWIG_Python_InitShadowInstance(args);
24276 }
24277
24278 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24279 PyObject *resultobj = 0;
24280 int arg1 = (int) 0 ;
24281 bool arg2 = (bool) false ;
24282 wxShowEvent *result = 0 ;
24283 int val1 ;
24284 int ecode1 = 0 ;
24285 bool val2 ;
24286 int ecode2 = 0 ;
24287 PyObject * obj0 = 0 ;
24288 PyObject * obj1 = 0 ;
24289 char * kwnames[] = {
24290 (char *) "winid",(char *) "show", NULL
24291 };
24292
24293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24294 if (obj0) {
24295 ecode1 = SWIG_AsVal_int(obj0, &val1);
24296 if (!SWIG_IsOK(ecode1)) {
24297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24298 }
24299 arg1 = static_cast< int >(val1);
24300 }
24301 if (obj1) {
24302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24303 if (!SWIG_IsOK(ecode2)) {
24304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24305 }
24306 arg2 = static_cast< bool >(val2);
24307 }
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24315 return resultobj;
24316 fail:
24317 return NULL;
24318 }
24319
24320
24321 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24322 PyObject *resultobj = 0;
24323 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24324 bool arg2 ;
24325 void *argp1 = 0 ;
24326 int res1 = 0 ;
24327 bool val2 ;
24328 int ecode2 = 0 ;
24329 PyObject * obj0 = 0 ;
24330 PyObject * obj1 = 0 ;
24331 char * kwnames[] = {
24332 (char *) "self",(char *) "show", NULL
24333 };
24334
24335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24337 if (!SWIG_IsOK(res1)) {
24338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24339 }
24340 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24341 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24342 if (!SWIG_IsOK(ecode2)) {
24343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24344 }
24345 arg2 = static_cast< bool >(val2);
24346 {
24347 PyThreadState* __tstate = wxPyBeginAllowThreads();
24348 (arg1)->SetShow(arg2);
24349 wxPyEndAllowThreads(__tstate);
24350 if (PyErr_Occurred()) SWIG_fail;
24351 }
24352 resultobj = SWIG_Py_Void();
24353 return resultobj;
24354 fail:
24355 return NULL;
24356 }
24357
24358
24359 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24360 PyObject *resultobj = 0;
24361 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24362 bool result;
24363 void *argp1 = 0 ;
24364 int res1 = 0 ;
24365 PyObject *swig_obj[1] ;
24366
24367 if (!args) SWIG_fail;
24368 swig_obj[0] = args;
24369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24370 if (!SWIG_IsOK(res1)) {
24371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24372 }
24373 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24374 {
24375 PyThreadState* __tstate = wxPyBeginAllowThreads();
24376 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24377 wxPyEndAllowThreads(__tstate);
24378 if (PyErr_Occurred()) SWIG_fail;
24379 }
24380 {
24381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24382 }
24383 return resultobj;
24384 fail:
24385 return NULL;
24386 }
24387
24388
24389 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24390 PyObject *obj;
24391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24392 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24393 return SWIG_Py_Void();
24394 }
24395
24396 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24397 return SWIG_Python_InitShadowInstance(args);
24398 }
24399
24400 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj = 0;
24402 int arg1 = (int) 0 ;
24403 bool arg2 = (bool) true ;
24404 wxIconizeEvent *result = 0 ;
24405 int val1 ;
24406 int ecode1 = 0 ;
24407 bool val2 ;
24408 int ecode2 = 0 ;
24409 PyObject * obj0 = 0 ;
24410 PyObject * obj1 = 0 ;
24411 char * kwnames[] = {
24412 (char *) "id",(char *) "iconized", NULL
24413 };
24414
24415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24416 if (obj0) {
24417 ecode1 = SWIG_AsVal_int(obj0, &val1);
24418 if (!SWIG_IsOK(ecode1)) {
24419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24420 }
24421 arg1 = static_cast< int >(val1);
24422 }
24423 if (obj1) {
24424 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24425 if (!SWIG_IsOK(ecode2)) {
24426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24427 }
24428 arg2 = static_cast< bool >(val2);
24429 }
24430 {
24431 PyThreadState* __tstate = wxPyBeginAllowThreads();
24432 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24433 wxPyEndAllowThreads(__tstate);
24434 if (PyErr_Occurred()) SWIG_fail;
24435 }
24436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24444 PyObject *resultobj = 0;
24445 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24446 bool result;
24447 void *argp1 = 0 ;
24448 int res1 = 0 ;
24449 PyObject *swig_obj[1] ;
24450
24451 if (!args) SWIG_fail;
24452 swig_obj[0] = args;
24453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24454 if (!SWIG_IsOK(res1)) {
24455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24456 }
24457 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 result = (bool)(arg1)->Iconized();
24461 wxPyEndAllowThreads(__tstate);
24462 if (PyErr_Occurred()) SWIG_fail;
24463 }
24464 {
24465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24466 }
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *obj;
24475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24476 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24477 return SWIG_Py_Void();
24478 }
24479
24480 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24481 return SWIG_Python_InitShadowInstance(args);
24482 }
24483
24484 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24485 PyObject *resultobj = 0;
24486 int arg1 = (int) 0 ;
24487 wxMaximizeEvent *result = 0 ;
24488 int val1 ;
24489 int ecode1 = 0 ;
24490 PyObject * obj0 = 0 ;
24491 char * kwnames[] = {
24492 (char *) "id", NULL
24493 };
24494
24495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24496 if (obj0) {
24497 ecode1 = SWIG_AsVal_int(obj0, &val1);
24498 if (!SWIG_IsOK(ecode1)) {
24499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24500 }
24501 arg1 = static_cast< int >(val1);
24502 }
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *obj;
24518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24519 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24520 return SWIG_Py_Void();
24521 }
24522
24523 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524 return SWIG_Python_InitShadowInstance(args);
24525 }
24526
24527 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24528 PyObject *resultobj = 0;
24529 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24530 wxPoint result;
24531 void *argp1 = 0 ;
24532 int res1 = 0 ;
24533 PyObject *swig_obj[1] ;
24534
24535 if (!args) SWIG_fail;
24536 swig_obj[0] = args;
24537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24538 if (!SWIG_IsOK(res1)) {
24539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24540 }
24541 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24542 {
24543 PyThreadState* __tstate = wxPyBeginAllowThreads();
24544 result = (arg1)->GetPosition();
24545 wxPyEndAllowThreads(__tstate);
24546 if (PyErr_Occurred()) SWIG_fail;
24547 }
24548 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 PyObject *resultobj = 0;
24557 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24558 int result;
24559 void *argp1 = 0 ;
24560 int res1 = 0 ;
24561 PyObject *swig_obj[1] ;
24562
24563 if (!args) SWIG_fail;
24564 swig_obj[0] = args;
24565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24568 }
24569 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = (int)(arg1)->GetNumberOfFiles();
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 resultobj = SWIG_From_int(static_cast< int >(result));
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24584 PyObject *resultobj = 0;
24585 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24586 PyObject *result = 0 ;
24587 void *argp1 = 0 ;
24588 int res1 = 0 ;
24589 PyObject *swig_obj[1] ;
24590
24591 if (!args) SWIG_fail;
24592 swig_obj[0] = args;
24593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24596 }
24597 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 resultobj = result;
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 PyObject *obj;
24613 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24614 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24615 return SWIG_Py_Void();
24616 }
24617
24618 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = 0;
24620 int arg1 = (int) 0 ;
24621 wxUpdateUIEvent *result = 0 ;
24622 int val1 ;
24623 int ecode1 = 0 ;
24624 PyObject * obj0 = 0 ;
24625 char * kwnames[] = {
24626 (char *) "commandId", NULL
24627 };
24628
24629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24630 if (obj0) {
24631 ecode1 = SWIG_AsVal_int(obj0, &val1);
24632 if (!SWIG_IsOK(ecode1)) {
24633 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24634 }
24635 arg1 = static_cast< int >(val1);
24636 }
24637 {
24638 PyThreadState* __tstate = wxPyBeginAllowThreads();
24639 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24640 wxPyEndAllowThreads(__tstate);
24641 if (PyErr_Occurred()) SWIG_fail;
24642 }
24643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24644 return resultobj;
24645 fail:
24646 return NULL;
24647 }
24648
24649
24650 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24651 PyObject *resultobj = 0;
24652 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24653 bool result;
24654 void *argp1 = 0 ;
24655 int res1 = 0 ;
24656 PyObject *swig_obj[1] ;
24657
24658 if (!args) SWIG_fail;
24659 swig_obj[0] = args;
24660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24661 if (!SWIG_IsOK(res1)) {
24662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24663 }
24664 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24665 {
24666 PyThreadState* __tstate = wxPyBeginAllowThreads();
24667 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24668 wxPyEndAllowThreads(__tstate);
24669 if (PyErr_Occurred()) SWIG_fail;
24670 }
24671 {
24672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24673 }
24674 return resultobj;
24675 fail:
24676 return NULL;
24677 }
24678
24679
24680 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24681 PyObject *resultobj = 0;
24682 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24683 bool result;
24684 void *argp1 = 0 ;
24685 int res1 = 0 ;
24686 PyObject *swig_obj[1] ;
24687
24688 if (!args) SWIG_fail;
24689 swig_obj[0] = args;
24690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24691 if (!SWIG_IsOK(res1)) {
24692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24693 }
24694 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24698 wxPyEndAllowThreads(__tstate);
24699 if (PyErr_Occurred()) SWIG_fail;
24700 }
24701 {
24702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24703 }
24704 return resultobj;
24705 fail:
24706 return NULL;
24707 }
24708
24709
24710 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24711 PyObject *resultobj = 0;
24712 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24713 bool result;
24714 void *argp1 = 0 ;
24715 int res1 = 0 ;
24716 PyObject *swig_obj[1] ;
24717
24718 if (!args) SWIG_fail;
24719 swig_obj[0] = args;
24720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24721 if (!SWIG_IsOK(res1)) {
24722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24723 }
24724 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24728 wxPyEndAllowThreads(__tstate);
24729 if (PyErr_Occurred()) SWIG_fail;
24730 }
24731 {
24732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24733 }
24734 return resultobj;
24735 fail:
24736 return NULL;
24737 }
24738
24739
24740 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24741 PyObject *resultobj = 0;
24742 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24743 wxString result;
24744 void *argp1 = 0 ;
24745 int res1 = 0 ;
24746 PyObject *swig_obj[1] ;
24747
24748 if (!args) SWIG_fail;
24749 swig_obj[0] = args;
24750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24751 if (!SWIG_IsOK(res1)) {
24752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24753 }
24754 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24755 {
24756 PyThreadState* __tstate = wxPyBeginAllowThreads();
24757 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24758 wxPyEndAllowThreads(__tstate);
24759 if (PyErr_Occurred()) SWIG_fail;
24760 }
24761 {
24762 #if wxUSE_UNICODE
24763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24764 #else
24765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24766 #endif
24767 }
24768 return resultobj;
24769 fail:
24770 return NULL;
24771 }
24772
24773
24774 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24775 PyObject *resultobj = 0;
24776 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24777 bool result;
24778 void *argp1 = 0 ;
24779 int res1 = 0 ;
24780 PyObject *swig_obj[1] ;
24781
24782 if (!args) SWIG_fail;
24783 swig_obj[0] = args;
24784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24785 if (!SWIG_IsOK(res1)) {
24786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24787 }
24788 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24792 wxPyEndAllowThreads(__tstate);
24793 if (PyErr_Occurred()) SWIG_fail;
24794 }
24795 {
24796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24797 }
24798 return resultobj;
24799 fail:
24800 return NULL;
24801 }
24802
24803
24804 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24805 PyObject *resultobj = 0;
24806 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24807 bool result;
24808 void *argp1 = 0 ;
24809 int res1 = 0 ;
24810 PyObject *swig_obj[1] ;
24811
24812 if (!args) SWIG_fail;
24813 swig_obj[0] = args;
24814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24815 if (!SWIG_IsOK(res1)) {
24816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24817 }
24818 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24819 {
24820 PyThreadState* __tstate = wxPyBeginAllowThreads();
24821 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24822 wxPyEndAllowThreads(__tstate);
24823 if (PyErr_Occurred()) SWIG_fail;
24824 }
24825 {
24826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24827 }
24828 return resultobj;
24829 fail:
24830 return NULL;
24831 }
24832
24833
24834 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24835 PyObject *resultobj = 0;
24836 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24837 bool result;
24838 void *argp1 = 0 ;
24839 int res1 = 0 ;
24840 PyObject *swig_obj[1] ;
24841
24842 if (!args) SWIG_fail;
24843 swig_obj[0] = args;
24844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24845 if (!SWIG_IsOK(res1)) {
24846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24847 }
24848 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 {
24856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24857 }
24858 return resultobj;
24859 fail:
24860 return NULL;
24861 }
24862
24863
24864 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24865 PyObject *resultobj = 0;
24866 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24867 bool result;
24868 void *argp1 = 0 ;
24869 int res1 = 0 ;
24870 PyObject *swig_obj[1] ;
24871
24872 if (!args) SWIG_fail;
24873 swig_obj[0] = args;
24874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24875 if (!SWIG_IsOK(res1)) {
24876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24877 }
24878 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24879 {
24880 PyThreadState* __tstate = wxPyBeginAllowThreads();
24881 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24882 wxPyEndAllowThreads(__tstate);
24883 if (PyErr_Occurred()) SWIG_fail;
24884 }
24885 {
24886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24887 }
24888 return resultobj;
24889 fail:
24890 return NULL;
24891 }
24892
24893
24894 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24895 PyObject *resultobj = 0;
24896 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24897 bool arg2 ;
24898 void *argp1 = 0 ;
24899 int res1 = 0 ;
24900 bool val2 ;
24901 int ecode2 = 0 ;
24902 PyObject * obj0 = 0 ;
24903 PyObject * obj1 = 0 ;
24904 char * kwnames[] = {
24905 (char *) "self",(char *) "check", NULL
24906 };
24907
24908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24910 if (!SWIG_IsOK(res1)) {
24911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24912 }
24913 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24914 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24915 if (!SWIG_IsOK(ecode2)) {
24916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24917 }
24918 arg2 = static_cast< bool >(val2);
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 (arg1)->Check(arg2);
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 resultobj = SWIG_Py_Void();
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24933 PyObject *resultobj = 0;
24934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24935 bool arg2 ;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 bool val2 ;
24939 int ecode2 = 0 ;
24940 PyObject * obj0 = 0 ;
24941 PyObject * obj1 = 0 ;
24942 char * kwnames[] = {
24943 (char *) "self",(char *) "enable", NULL
24944 };
24945
24946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24948 if (!SWIG_IsOK(res1)) {
24949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24950 }
24951 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24953 if (!SWIG_IsOK(ecode2)) {
24954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24955 }
24956 arg2 = static_cast< bool >(val2);
24957 {
24958 PyThreadState* __tstate = wxPyBeginAllowThreads();
24959 (arg1)->Enable(arg2);
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 resultobj = SWIG_Py_Void();
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24971 PyObject *resultobj = 0;
24972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24973 bool arg2 ;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 bool val2 ;
24977 int ecode2 = 0 ;
24978 PyObject * obj0 = 0 ;
24979 PyObject * obj1 = 0 ;
24980 char * kwnames[] = {
24981 (char *) "self",(char *) "show", NULL
24982 };
24983
24984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24986 if (!SWIG_IsOK(res1)) {
24987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24988 }
24989 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24991 if (!SWIG_IsOK(ecode2)) {
24992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24993 }
24994 arg2 = static_cast< bool >(val2);
24995 {
24996 PyThreadState* __tstate = wxPyBeginAllowThreads();
24997 (arg1)->Show(arg2);
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 resultobj = SWIG_Py_Void();
25002 return resultobj;
25003 fail:
25004 return NULL;
25005 }
25006
25007
25008 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25009 PyObject *resultobj = 0;
25010 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25011 wxString *arg2 = 0 ;
25012 void *argp1 = 0 ;
25013 int res1 = 0 ;
25014 bool temp2 = false ;
25015 PyObject * obj0 = 0 ;
25016 PyObject * obj1 = 0 ;
25017 char * kwnames[] = {
25018 (char *) "self",(char *) "text", NULL
25019 };
25020
25021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25023 if (!SWIG_IsOK(res1)) {
25024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25025 }
25026 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25027 {
25028 arg2 = wxString_in_helper(obj1);
25029 if (arg2 == NULL) SWIG_fail;
25030 temp2 = true;
25031 }
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 (arg1)->SetText((wxString const &)*arg2);
25035 wxPyEndAllowThreads(__tstate);
25036 if (PyErr_Occurred()) SWIG_fail;
25037 }
25038 resultobj = SWIG_Py_Void();
25039 {
25040 if (temp2)
25041 delete arg2;
25042 }
25043 return resultobj;
25044 fail:
25045 {
25046 if (temp2)
25047 delete arg2;
25048 }
25049 return NULL;
25050 }
25051
25052
25053 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25054 PyObject *resultobj = 0;
25055 long arg1 ;
25056 long val1 ;
25057 int ecode1 = 0 ;
25058 PyObject * obj0 = 0 ;
25059 char * kwnames[] = {
25060 (char *) "updateInterval", NULL
25061 };
25062
25063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25064 ecode1 = SWIG_AsVal_long(obj0, &val1);
25065 if (!SWIG_IsOK(ecode1)) {
25066 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25067 }
25068 arg1 = static_cast< long >(val1);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 wxUpdateUIEvent::SetUpdateInterval(arg1);
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_Py_Void();
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25083 PyObject *resultobj = 0;
25084 long result;
25085
25086 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 resultobj = SWIG_From_long(static_cast< long >(result));
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25101 PyObject *resultobj = 0;
25102 wxWindow *arg1 = (wxWindow *) 0 ;
25103 bool result;
25104 void *argp1 = 0 ;
25105 int res1 = 0 ;
25106 PyObject * obj0 = 0 ;
25107 char * kwnames[] = {
25108 (char *) "win", NULL
25109 };
25110
25111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25115 }
25116 arg1 = reinterpret_cast< wxWindow * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25125 }
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25133 PyObject *resultobj = 0;
25134
25135 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25136 {
25137 PyThreadState* __tstate = wxPyBeginAllowThreads();
25138 wxUpdateUIEvent::ResetUpdateTime();
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 resultobj = SWIG_Py_Void();
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = 0;
25151 wxUpdateUIMode arg1 ;
25152 int val1 ;
25153 int ecode1 = 0 ;
25154 PyObject * obj0 = 0 ;
25155 char * kwnames[] = {
25156 (char *) "mode", NULL
25157 };
25158
25159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25160 ecode1 = SWIG_AsVal_int(obj0, &val1);
25161 if (!SWIG_IsOK(ecode1)) {
25162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25163 }
25164 arg1 = static_cast< wxUpdateUIMode >(val1);
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 wxUpdateUIEvent::SetMode(arg1);
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 resultobj = SWIG_Py_Void();
25172 return resultobj;
25173 fail:
25174 return NULL;
25175 }
25176
25177
25178 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25179 PyObject *resultobj = 0;
25180 wxUpdateUIMode result;
25181
25182 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_From_int(static_cast< int >(result));
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *obj;
25198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25199 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25200 return SWIG_Py_Void();
25201 }
25202
25203 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25204 return SWIG_Python_InitShadowInstance(args);
25205 }
25206
25207 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25208 PyObject *resultobj = 0;
25209 wxSysColourChangedEvent *result = 0 ;
25210
25211 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25219 return resultobj;
25220 fail:
25221 return NULL;
25222 }
25223
25224
25225 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25226 PyObject *obj;
25227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25228 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25229 return SWIG_Py_Void();
25230 }
25231
25232 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 return SWIG_Python_InitShadowInstance(args);
25234 }
25235
25236 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25237 PyObject *resultobj = 0;
25238 int arg1 = (int) 0 ;
25239 wxWindow *arg2 = (wxWindow *) NULL ;
25240 wxMouseCaptureChangedEvent *result = 0 ;
25241 int val1 ;
25242 int ecode1 = 0 ;
25243 void *argp2 = 0 ;
25244 int res2 = 0 ;
25245 PyObject * obj0 = 0 ;
25246 PyObject * obj1 = 0 ;
25247 char * kwnames[] = {
25248 (char *) "winid",(char *) "gainedCapture", NULL
25249 };
25250
25251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25252 if (obj0) {
25253 ecode1 = SWIG_AsVal_int(obj0, &val1);
25254 if (!SWIG_IsOK(ecode1)) {
25255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25256 }
25257 arg1 = static_cast< int >(val1);
25258 }
25259 if (obj1) {
25260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25261 if (!SWIG_IsOK(res2)) {
25262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25263 }
25264 arg2 = reinterpret_cast< wxWindow * >(argp2);
25265 }
25266 {
25267 PyThreadState* __tstate = wxPyBeginAllowThreads();
25268 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25269 wxPyEndAllowThreads(__tstate);
25270 if (PyErr_Occurred()) SWIG_fail;
25271 }
25272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280 PyObject *resultobj = 0;
25281 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25282 wxWindow *result = 0 ;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 PyObject *swig_obj[1] ;
25286
25287 if (!args) SWIG_fail;
25288 swig_obj[0] = args;
25289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25290 if (!SWIG_IsOK(res1)) {
25291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25292 }
25293 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 {
25301 resultobj = wxPyMake_wxObject(result, (bool)0);
25302 }
25303 return resultobj;
25304 fail:
25305 return NULL;
25306 }
25307
25308
25309 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25310 PyObject *obj;
25311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25312 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25313 return SWIG_Py_Void();
25314 }
25315
25316 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25317 return SWIG_Python_InitShadowInstance(args);
25318 }
25319
25320 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 PyObject *resultobj = 0;
25322 wxDisplayChangedEvent *result = 0 ;
25323
25324 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25325 {
25326 PyThreadState* __tstate = wxPyBeginAllowThreads();
25327 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25328 wxPyEndAllowThreads(__tstate);
25329 if (PyErr_Occurred()) SWIG_fail;
25330 }
25331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25339 PyObject *obj;
25340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25341 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25342 return SWIG_Py_Void();
25343 }
25344
25345 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 return SWIG_Python_InitShadowInstance(args);
25347 }
25348
25349 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 int arg1 = (int) 0 ;
25352 wxPaletteChangedEvent *result = 0 ;
25353 int val1 ;
25354 int ecode1 = 0 ;
25355 PyObject * obj0 = 0 ;
25356 char * kwnames[] = {
25357 (char *) "id", NULL
25358 };
25359
25360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25361 if (obj0) {
25362 ecode1 = SWIG_AsVal_int(obj0, &val1);
25363 if (!SWIG_IsOK(ecode1)) {
25364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25365 }
25366 arg1 = static_cast< int >(val1);
25367 }
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = 0;
25383 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25384 wxWindow *arg2 = (wxWindow *) 0 ;
25385 void *argp1 = 0 ;
25386 int res1 = 0 ;
25387 void *argp2 = 0 ;
25388 int res2 = 0 ;
25389 PyObject * obj0 = 0 ;
25390 PyObject * obj1 = 0 ;
25391 char * kwnames[] = {
25392 (char *) "self",(char *) "win", NULL
25393 };
25394
25395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25397 if (!SWIG_IsOK(res1)) {
25398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25399 }
25400 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25401 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25402 if (!SWIG_IsOK(res2)) {
25403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25404 }
25405 arg2 = reinterpret_cast< wxWindow * >(argp2);
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 (arg1)->SetChangedWindow(arg2);
25409 wxPyEndAllowThreads(__tstate);
25410 if (PyErr_Occurred()) SWIG_fail;
25411 }
25412 resultobj = SWIG_Py_Void();
25413 return resultobj;
25414 fail:
25415 return NULL;
25416 }
25417
25418
25419 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25420 PyObject *resultobj = 0;
25421 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25422 wxWindow *result = 0 ;
25423 void *argp1 = 0 ;
25424 int res1 = 0 ;
25425 PyObject *swig_obj[1] ;
25426
25427 if (!args) SWIG_fail;
25428 swig_obj[0] = args;
25429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25430 if (!SWIG_IsOK(res1)) {
25431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25432 }
25433 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25434 {
25435 PyThreadState* __tstate = wxPyBeginAllowThreads();
25436 result = (wxWindow *)(arg1)->GetChangedWindow();
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 {
25441 resultobj = wxPyMake_wxObject(result, (bool)0);
25442 }
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *obj;
25451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25452 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25453 return SWIG_Py_Void();
25454 }
25455
25456 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 return SWIG_Python_InitShadowInstance(args);
25458 }
25459
25460 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25461 PyObject *resultobj = 0;
25462 int arg1 = (int) 0 ;
25463 wxQueryNewPaletteEvent *result = 0 ;
25464 int val1 ;
25465 int ecode1 = 0 ;
25466 PyObject * obj0 = 0 ;
25467 char * kwnames[] = {
25468 (char *) "winid", NULL
25469 };
25470
25471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25472 if (obj0) {
25473 ecode1 = SWIG_AsVal_int(obj0, &val1);
25474 if (!SWIG_IsOK(ecode1)) {
25475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25476 }
25477 arg1 = static_cast< int >(val1);
25478 }
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25486 return resultobj;
25487 fail:
25488 return NULL;
25489 }
25490
25491
25492 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25493 PyObject *resultobj = 0;
25494 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25495 bool arg2 ;
25496 void *argp1 = 0 ;
25497 int res1 = 0 ;
25498 bool val2 ;
25499 int ecode2 = 0 ;
25500 PyObject * obj0 = 0 ;
25501 PyObject * obj1 = 0 ;
25502 char * kwnames[] = {
25503 (char *) "self",(char *) "realized", NULL
25504 };
25505
25506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25510 }
25511 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25513 if (!SWIG_IsOK(ecode2)) {
25514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25515 }
25516 arg2 = static_cast< bool >(val2);
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 (arg1)->SetPaletteRealized(arg2);
25520 wxPyEndAllowThreads(__tstate);
25521 if (PyErr_Occurred()) SWIG_fail;
25522 }
25523 resultobj = SWIG_Py_Void();
25524 return resultobj;
25525 fail:
25526 return NULL;
25527 }
25528
25529
25530 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25531 PyObject *resultobj = 0;
25532 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25533 bool result;
25534 void *argp1 = 0 ;
25535 int res1 = 0 ;
25536 PyObject *swig_obj[1] ;
25537
25538 if (!args) SWIG_fail;
25539 swig_obj[0] = args;
25540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25541 if (!SWIG_IsOK(res1)) {
25542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25543 }
25544 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25545 {
25546 PyThreadState* __tstate = wxPyBeginAllowThreads();
25547 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25548 wxPyEndAllowThreads(__tstate);
25549 if (PyErr_Occurred()) SWIG_fail;
25550 }
25551 {
25552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25553 }
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25561 PyObject *obj;
25562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25563 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25564 return SWIG_Py_Void();
25565 }
25566
25567 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25568 return SWIG_Python_InitShadowInstance(args);
25569 }
25570
25571 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25572 PyObject *resultobj = 0;
25573 wxNavigationKeyEvent *result = 0 ;
25574
25575 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25590 PyObject *resultobj = 0;
25591 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25592 bool result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject *swig_obj[1] ;
25596
25597 if (!args) SWIG_fail;
25598 swig_obj[0] = args;
25599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25600 if (!SWIG_IsOK(res1)) {
25601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25602 }
25603 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25604 {
25605 PyThreadState* __tstate = wxPyBeginAllowThreads();
25606 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 {
25611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25612 }
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj = 0;
25621 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25622 bool arg2 ;
25623 void *argp1 = 0 ;
25624 int res1 = 0 ;
25625 bool val2 ;
25626 int ecode2 = 0 ;
25627 PyObject * obj0 = 0 ;
25628 PyObject * obj1 = 0 ;
25629 char * kwnames[] = {
25630 (char *) "self",(char *) "forward", NULL
25631 };
25632
25633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25635 if (!SWIG_IsOK(res1)) {
25636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25637 }
25638 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25640 if (!SWIG_IsOK(ecode2)) {
25641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25642 }
25643 arg2 = static_cast< bool >(val2);
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 (arg1)->SetDirection(arg2);
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 resultobj = SWIG_Py_Void();
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *resultobj = 0;
25659 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25660 bool result;
25661 void *argp1 = 0 ;
25662 int res1 = 0 ;
25663 PyObject *swig_obj[1] ;
25664
25665 if (!args) SWIG_fail;
25666 swig_obj[0] = args;
25667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25668 if (!SWIG_IsOK(res1)) {
25669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25670 }
25671 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 {
25679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj = 0;
25689 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25690 bool arg2 ;
25691 void *argp1 = 0 ;
25692 int res1 = 0 ;
25693 bool val2 ;
25694 int ecode2 = 0 ;
25695 PyObject * obj0 = 0 ;
25696 PyObject * obj1 = 0 ;
25697 char * kwnames[] = {
25698 (char *) "self",(char *) "ischange", NULL
25699 };
25700
25701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25703 if (!SWIG_IsOK(res1)) {
25704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25705 }
25706 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25707 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25708 if (!SWIG_IsOK(ecode2)) {
25709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25710 }
25711 arg2 = static_cast< bool >(val2);
25712 {
25713 PyThreadState* __tstate = wxPyBeginAllowThreads();
25714 (arg1)->SetWindowChange(arg2);
25715 wxPyEndAllowThreads(__tstate);
25716 if (PyErr_Occurred()) SWIG_fail;
25717 }
25718 resultobj = SWIG_Py_Void();
25719 return resultobj;
25720 fail:
25721 return NULL;
25722 }
25723
25724
25725 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25726 PyObject *resultobj = 0;
25727 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25728 bool result;
25729 void *argp1 = 0 ;
25730 int res1 = 0 ;
25731 PyObject *swig_obj[1] ;
25732
25733 if (!args) SWIG_fail;
25734 swig_obj[0] = args;
25735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25736 if (!SWIG_IsOK(res1)) {
25737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25738 }
25739 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25740 {
25741 PyThreadState* __tstate = wxPyBeginAllowThreads();
25742 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25743 wxPyEndAllowThreads(__tstate);
25744 if (PyErr_Occurred()) SWIG_fail;
25745 }
25746 {
25747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25748 }
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = 0;
25757 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25758 bool arg2 ;
25759 void *argp1 = 0 ;
25760 int res1 = 0 ;
25761 bool val2 ;
25762 int ecode2 = 0 ;
25763 PyObject * obj0 = 0 ;
25764 PyObject * obj1 = 0 ;
25765 char * kwnames[] = {
25766 (char *) "self",(char *) "bIs", NULL
25767 };
25768
25769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25771 if (!SWIG_IsOK(res1)) {
25772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25773 }
25774 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25775 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25776 if (!SWIG_IsOK(ecode2)) {
25777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25778 }
25779 arg2 = static_cast< bool >(val2);
25780 {
25781 PyThreadState* __tstate = wxPyBeginAllowThreads();
25782 (arg1)->SetFromTab(arg2);
25783 wxPyEndAllowThreads(__tstate);
25784 if (PyErr_Occurred()) SWIG_fail;
25785 }
25786 resultobj = SWIG_Py_Void();
25787 return resultobj;
25788 fail:
25789 return NULL;
25790 }
25791
25792
25793 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25794 PyObject *resultobj = 0;
25795 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25796 long arg2 ;
25797 void *argp1 = 0 ;
25798 int res1 = 0 ;
25799 long val2 ;
25800 int ecode2 = 0 ;
25801 PyObject * obj0 = 0 ;
25802 PyObject * obj1 = 0 ;
25803 char * kwnames[] = {
25804 (char *) "self",(char *) "flags", NULL
25805 };
25806
25807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25809 if (!SWIG_IsOK(res1)) {
25810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25811 }
25812 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25813 ecode2 = SWIG_AsVal_long(obj1, &val2);
25814 if (!SWIG_IsOK(ecode2)) {
25815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25816 }
25817 arg2 = static_cast< long >(val2);
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 (arg1)->SetFlags(arg2);
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 resultobj = SWIG_Py_Void();
25825 return resultobj;
25826 fail:
25827 return NULL;
25828 }
25829
25830
25831 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25832 PyObject *resultobj = 0;
25833 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25834 wxWindow *result = 0 ;
25835 void *argp1 = 0 ;
25836 int res1 = 0 ;
25837 PyObject *swig_obj[1] ;
25838
25839 if (!args) SWIG_fail;
25840 swig_obj[0] = args;
25841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25842 if (!SWIG_IsOK(res1)) {
25843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25844 }
25845 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25846 {
25847 PyThreadState* __tstate = wxPyBeginAllowThreads();
25848 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 {
25853 resultobj = wxPyMake_wxObject(result, (bool)0);
25854 }
25855 return resultobj;
25856 fail:
25857 return NULL;
25858 }
25859
25860
25861 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25862 PyObject *resultobj = 0;
25863 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25864 wxWindow *arg2 = (wxWindow *) 0 ;
25865 void *argp1 = 0 ;
25866 int res1 = 0 ;
25867 void *argp2 = 0 ;
25868 int res2 = 0 ;
25869 PyObject * obj0 = 0 ;
25870 PyObject * obj1 = 0 ;
25871 char * kwnames[] = {
25872 (char *) "self",(char *) "win", NULL
25873 };
25874
25875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25877 if (!SWIG_IsOK(res1)) {
25878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25879 }
25880 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25882 if (!SWIG_IsOK(res2)) {
25883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25884 }
25885 arg2 = reinterpret_cast< wxWindow * >(argp2);
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 (arg1)->SetCurrentFocus(arg2);
25889 wxPyEndAllowThreads(__tstate);
25890 if (PyErr_Occurred()) SWIG_fail;
25891 }
25892 resultobj = SWIG_Py_Void();
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25900 PyObject *obj;
25901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25902 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25903 return SWIG_Py_Void();
25904 }
25905
25906 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25907 return SWIG_Python_InitShadowInstance(args);
25908 }
25909
25910 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25911 PyObject *resultobj = 0;
25912 wxWindow *arg1 = (wxWindow *) NULL ;
25913 wxWindowCreateEvent *result = 0 ;
25914 void *argp1 = 0 ;
25915 int res1 = 0 ;
25916 PyObject * obj0 = 0 ;
25917 char * kwnames[] = {
25918 (char *) "win", NULL
25919 };
25920
25921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25922 if (obj0) {
25923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25924 if (!SWIG_IsOK(res1)) {
25925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25926 }
25927 arg1 = reinterpret_cast< wxWindow * >(argp1);
25928 }
25929 {
25930 PyThreadState* __tstate = wxPyBeginAllowThreads();
25931 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25943 PyObject *resultobj = 0;
25944 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25945 wxWindow *result = 0 ;
25946 void *argp1 = 0 ;
25947 int res1 = 0 ;
25948 PyObject *swig_obj[1] ;
25949
25950 if (!args) SWIG_fail;
25951 swig_obj[0] = args;
25952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25953 if (!SWIG_IsOK(res1)) {
25954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25955 }
25956 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25957 {
25958 PyThreadState* __tstate = wxPyBeginAllowThreads();
25959 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25960 wxPyEndAllowThreads(__tstate);
25961 if (PyErr_Occurred()) SWIG_fail;
25962 }
25963 {
25964 resultobj = wxPyMake_wxObject(result, (bool)0);
25965 }
25966 return resultobj;
25967 fail:
25968 return NULL;
25969 }
25970
25971
25972 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25973 PyObject *obj;
25974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25975 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25976 return SWIG_Py_Void();
25977 }
25978
25979 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25980 return SWIG_Python_InitShadowInstance(args);
25981 }
25982
25983 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25984 PyObject *resultobj = 0;
25985 wxWindow *arg1 = (wxWindow *) NULL ;
25986 wxWindowDestroyEvent *result = 0 ;
25987 void *argp1 = 0 ;
25988 int res1 = 0 ;
25989 PyObject * obj0 = 0 ;
25990 char * kwnames[] = {
25991 (char *) "win", NULL
25992 };
25993
25994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25995 if (obj0) {
25996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25999 }
26000 arg1 = reinterpret_cast< wxWindow * >(argp1);
26001 }
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26016 PyObject *resultobj = 0;
26017 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26018 wxWindow *result = 0 ;
26019 void *argp1 = 0 ;
26020 int res1 = 0 ;
26021 PyObject *swig_obj[1] ;
26022
26023 if (!args) SWIG_fail;
26024 swig_obj[0] = args;
26025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26028 }
26029 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 {
26037 resultobj = wxPyMake_wxObject(result, (bool)0);
26038 }
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26046 PyObject *obj;
26047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26048 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26049 return SWIG_Py_Void();
26050 }
26051
26052 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26053 return SWIG_Python_InitShadowInstance(args);
26054 }
26055
26056 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj = 0;
26058 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26059 int arg2 = (int) 0 ;
26060 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26061 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26062 wxContextMenuEvent *result = 0 ;
26063 int val1 ;
26064 int ecode1 = 0 ;
26065 int val2 ;
26066 int ecode2 = 0 ;
26067 wxPoint temp3 ;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 PyObject * obj2 = 0 ;
26071 char * kwnames[] = {
26072 (char *) "type",(char *) "winid",(char *) "pt", NULL
26073 };
26074
26075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26076 if (obj0) {
26077 ecode1 = SWIG_AsVal_int(obj0, &val1);
26078 if (!SWIG_IsOK(ecode1)) {
26079 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26080 }
26081 arg1 = static_cast< wxEventType >(val1);
26082 }
26083 if (obj1) {
26084 ecode2 = SWIG_AsVal_int(obj1, &val2);
26085 if (!SWIG_IsOK(ecode2)) {
26086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26087 }
26088 arg2 = static_cast< int >(val2);
26089 }
26090 if (obj2) {
26091 {
26092 arg3 = &temp3;
26093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26094 }
26095 }
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26099 wxPyEndAllowThreads(__tstate);
26100 if (PyErr_Occurred()) SWIG_fail;
26101 }
26102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26103 return resultobj;
26104 fail:
26105 return NULL;
26106 }
26107
26108
26109 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26110 PyObject *resultobj = 0;
26111 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26112 wxPoint *result = 0 ;
26113 void *argp1 = 0 ;
26114 int res1 = 0 ;
26115 PyObject *swig_obj[1] ;
26116
26117 if (!args) SWIG_fail;
26118 swig_obj[0] = args;
26119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26120 if (!SWIG_IsOK(res1)) {
26121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26122 }
26123 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26124 {
26125 PyThreadState* __tstate = wxPyBeginAllowThreads();
26126 {
26127 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26128 result = (wxPoint *) &_result_ref;
26129 }
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26141 PyObject *resultobj = 0;
26142 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26143 wxPoint *arg2 = 0 ;
26144 void *argp1 = 0 ;
26145 int res1 = 0 ;
26146 wxPoint temp2 ;
26147 PyObject * obj0 = 0 ;
26148 PyObject * obj1 = 0 ;
26149 char * kwnames[] = {
26150 (char *) "self",(char *) "pos", NULL
26151 };
26152
26153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26155 if (!SWIG_IsOK(res1)) {
26156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26157 }
26158 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26159 {
26160 arg2 = &temp2;
26161 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26162 }
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 (arg1)->SetPosition((wxPoint const &)*arg2);
26166 wxPyEndAllowThreads(__tstate);
26167 if (PyErr_Occurred()) SWIG_fail;
26168 }
26169 resultobj = SWIG_Py_Void();
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 PyObject *obj;
26178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26179 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26180 return SWIG_Py_Void();
26181 }
26182
26183 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26184 return SWIG_Python_InitShadowInstance(args);
26185 }
26186
26187 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26188 PyObject *resultobj = 0;
26189 wxIdleEvent *result = 0 ;
26190
26191 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26192 {
26193 PyThreadState* __tstate = wxPyBeginAllowThreads();
26194 result = (wxIdleEvent *)new wxIdleEvent();
26195 wxPyEndAllowThreads(__tstate);
26196 if (PyErr_Occurred()) SWIG_fail;
26197 }
26198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26206 PyObject *resultobj = 0;
26207 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26208 bool arg2 = (bool) true ;
26209 void *argp1 = 0 ;
26210 int res1 = 0 ;
26211 bool val2 ;
26212 int ecode2 = 0 ;
26213 PyObject * obj0 = 0 ;
26214 PyObject * obj1 = 0 ;
26215 char * kwnames[] = {
26216 (char *) "self",(char *) "needMore", NULL
26217 };
26218
26219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26221 if (!SWIG_IsOK(res1)) {
26222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26223 }
26224 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26225 if (obj1) {
26226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26227 if (!SWIG_IsOK(ecode2)) {
26228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26229 }
26230 arg2 = static_cast< bool >(val2);
26231 }
26232 {
26233 PyThreadState* __tstate = wxPyBeginAllowThreads();
26234 (arg1)->RequestMore(arg2);
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 resultobj = SWIG_Py_Void();
26239 return resultobj;
26240 fail:
26241 return NULL;
26242 }
26243
26244
26245 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 PyObject *resultobj = 0;
26247 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26248 bool result;
26249 void *argp1 = 0 ;
26250 int res1 = 0 ;
26251 PyObject *swig_obj[1] ;
26252
26253 if (!args) SWIG_fail;
26254 swig_obj[0] = args;
26255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26256 if (!SWIG_IsOK(res1)) {
26257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26258 }
26259 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26260 {
26261 PyThreadState* __tstate = wxPyBeginAllowThreads();
26262 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26263 wxPyEndAllowThreads(__tstate);
26264 if (PyErr_Occurred()) SWIG_fail;
26265 }
26266 {
26267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26268 }
26269 return resultobj;
26270 fail:
26271 return NULL;
26272 }
26273
26274
26275 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26276 PyObject *resultobj = 0;
26277 wxIdleMode arg1 ;
26278 int val1 ;
26279 int ecode1 = 0 ;
26280 PyObject * obj0 = 0 ;
26281 char * kwnames[] = {
26282 (char *) "mode", NULL
26283 };
26284
26285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26286 ecode1 = SWIG_AsVal_int(obj0, &val1);
26287 if (!SWIG_IsOK(ecode1)) {
26288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26289 }
26290 arg1 = static_cast< wxIdleMode >(val1);
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 wxIdleEvent::SetMode(arg1);
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 *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *resultobj = 0;
26306 wxIdleMode result;
26307
26308 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26309 {
26310 PyThreadState* __tstate = wxPyBeginAllowThreads();
26311 result = (wxIdleMode)wxIdleEvent::GetMode();
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_From_int(static_cast< int >(result));
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = 0;
26324 wxWindow *arg1 = (wxWindow *) 0 ;
26325 bool result;
26326 void *argp1 = 0 ;
26327 int res1 = 0 ;
26328 PyObject * obj0 = 0 ;
26329 char * kwnames[] = {
26330 (char *) "win", NULL
26331 };
26332
26333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26335 if (!SWIG_IsOK(res1)) {
26336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26337 }
26338 arg1 = reinterpret_cast< wxWindow * >(argp1);
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 result = (bool)wxIdleEvent::CanSend(arg1);
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 {
26346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26347 }
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26355 PyObject *obj;
26356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26357 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26358 return SWIG_Py_Void();
26359 }
26360
26361 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26362 return SWIG_Python_InitShadowInstance(args);
26363 }
26364
26365 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj = 0;
26367 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26368 int arg2 = (int) 0 ;
26369 wxClipboardTextEvent *result = 0 ;
26370 int val1 ;
26371 int ecode1 = 0 ;
26372 int val2 ;
26373 int ecode2 = 0 ;
26374 PyObject * obj0 = 0 ;
26375 PyObject * obj1 = 0 ;
26376 char * kwnames[] = {
26377 (char *) "type",(char *) "winid", NULL
26378 };
26379
26380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26381 if (obj0) {
26382 ecode1 = SWIG_AsVal_int(obj0, &val1);
26383 if (!SWIG_IsOK(ecode1)) {
26384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26385 }
26386 arg1 = static_cast< wxEventType >(val1);
26387 }
26388 if (obj1) {
26389 ecode2 = SWIG_AsVal_int(obj1, &val2);
26390 if (!SWIG_IsOK(ecode2)) {
26391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26392 }
26393 arg2 = static_cast< int >(val2);
26394 }
26395 {
26396 PyThreadState* __tstate = wxPyBeginAllowThreads();
26397 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26398 wxPyEndAllowThreads(__tstate);
26399 if (PyErr_Occurred()) SWIG_fail;
26400 }
26401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26402 return resultobj;
26403 fail:
26404 return NULL;
26405 }
26406
26407
26408 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26409 PyObject *obj;
26410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26411 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26412 return SWIG_Py_Void();
26413 }
26414
26415 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26416 return SWIG_Python_InitShadowInstance(args);
26417 }
26418
26419 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26420 PyObject *resultobj = 0;
26421 int arg1 = (int) 0 ;
26422 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26423 wxPyEvent *result = 0 ;
26424 int val1 ;
26425 int ecode1 = 0 ;
26426 int val2 ;
26427 int ecode2 = 0 ;
26428 PyObject * obj0 = 0 ;
26429 PyObject * obj1 = 0 ;
26430 char * kwnames[] = {
26431 (char *) "winid",(char *) "eventType", NULL
26432 };
26433
26434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26435 if (obj0) {
26436 ecode1 = SWIG_AsVal_int(obj0, &val1);
26437 if (!SWIG_IsOK(ecode1)) {
26438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26439 }
26440 arg1 = static_cast< int >(val1);
26441 }
26442 if (obj1) {
26443 ecode2 = SWIG_AsVal_int(obj1, &val2);
26444 if (!SWIG_IsOK(ecode2)) {
26445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26446 }
26447 arg2 = static_cast< wxEventType >(val2);
26448 }
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26456 return resultobj;
26457 fail:
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26463 PyObject *resultobj = 0;
26464 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26465 void *argp1 = 0 ;
26466 int res1 = 0 ;
26467 PyObject *swig_obj[1] ;
26468
26469 if (!args) SWIG_fail;
26470 swig_obj[0] = args;
26471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26472 if (!SWIG_IsOK(res1)) {
26473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26474 }
26475 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26476 {
26477 PyThreadState* __tstate = wxPyBeginAllowThreads();
26478 delete arg1;
26479
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_Py_Void();
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26491 PyObject *resultobj = 0;
26492 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26493 PyObject *arg2 = (PyObject *) 0 ;
26494 void *argp1 = 0 ;
26495 int res1 = 0 ;
26496 PyObject * obj0 = 0 ;
26497 PyObject * obj1 = 0 ;
26498 char * kwnames[] = {
26499 (char *) "self",(char *) "self", NULL
26500 };
26501
26502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26504 if (!SWIG_IsOK(res1)) {
26505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26506 }
26507 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26508 arg2 = obj1;
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 (arg1)->SetSelf(arg2);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_Py_Void();
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 PyObject *resultobj = 0;
26524 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26525 PyObject *result = 0 ;
26526 void *argp1 = 0 ;
26527 int res1 = 0 ;
26528 PyObject *swig_obj[1] ;
26529
26530 if (!args) SWIG_fail;
26531 swig_obj[0] = args;
26532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26533 if (!SWIG_IsOK(res1)) {
26534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26535 }
26536 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = (PyObject *)(arg1)->GetSelf();
26540 wxPyEndAllowThreads(__tstate);
26541 if (PyErr_Occurred()) SWIG_fail;
26542 }
26543 resultobj = result;
26544 return resultobj;
26545 fail:
26546 return NULL;
26547 }
26548
26549
26550 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26551 PyObject *obj;
26552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26553 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26554 return SWIG_Py_Void();
26555 }
26556
26557 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26558 return SWIG_Python_InitShadowInstance(args);
26559 }
26560
26561 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26562 PyObject *resultobj = 0;
26563 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26564 int arg2 = (int) 0 ;
26565 wxPyCommandEvent *result = 0 ;
26566 int val1 ;
26567 int ecode1 = 0 ;
26568 int val2 ;
26569 int ecode2 = 0 ;
26570 PyObject * obj0 = 0 ;
26571 PyObject * obj1 = 0 ;
26572 char * kwnames[] = {
26573 (char *) "eventType",(char *) "id", NULL
26574 };
26575
26576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26577 if (obj0) {
26578 ecode1 = SWIG_AsVal_int(obj0, &val1);
26579 if (!SWIG_IsOK(ecode1)) {
26580 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26581 }
26582 arg1 = static_cast< wxEventType >(val1);
26583 }
26584 if (obj1) {
26585 ecode2 = SWIG_AsVal_int(obj1, &val2);
26586 if (!SWIG_IsOK(ecode2)) {
26587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26588 }
26589 arg2 = static_cast< int >(val2);
26590 }
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26594 wxPyEndAllowThreads(__tstate);
26595 if (PyErr_Occurred()) SWIG_fail;
26596 }
26597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26605 PyObject *resultobj = 0;
26606 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject *swig_obj[1] ;
26610
26611 if (!args) SWIG_fail;
26612 swig_obj[0] = args;
26613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26616 }
26617 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 delete arg1;
26621
26622 wxPyEndAllowThreads(__tstate);
26623 if (PyErr_Occurred()) SWIG_fail;
26624 }
26625 resultobj = SWIG_Py_Void();
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26633 PyObject *resultobj = 0;
26634 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26635 PyObject *arg2 = (PyObject *) 0 ;
26636 void *argp1 = 0 ;
26637 int res1 = 0 ;
26638 PyObject * obj0 = 0 ;
26639 PyObject * obj1 = 0 ;
26640 char * kwnames[] = {
26641 (char *) "self",(char *) "self", NULL
26642 };
26643
26644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26646 if (!SWIG_IsOK(res1)) {
26647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26648 }
26649 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26650 arg2 = obj1;
26651 {
26652 PyThreadState* __tstate = wxPyBeginAllowThreads();
26653 (arg1)->SetSelf(arg2);
26654 wxPyEndAllowThreads(__tstate);
26655 if (PyErr_Occurred()) SWIG_fail;
26656 }
26657 resultobj = SWIG_Py_Void();
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26665 PyObject *resultobj = 0;
26666 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26667 PyObject *result = 0 ;
26668 void *argp1 = 0 ;
26669 int res1 = 0 ;
26670 PyObject *swig_obj[1] ;
26671
26672 if (!args) SWIG_fail;
26673 swig_obj[0] = args;
26674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26675 if (!SWIG_IsOK(res1)) {
26676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26677 }
26678 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 result = (PyObject *)(arg1)->GetSelf();
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 resultobj = result;
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26693 PyObject *obj;
26694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26696 return SWIG_Py_Void();
26697 }
26698
26699 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26700 return SWIG_Python_InitShadowInstance(args);
26701 }
26702
26703 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26704 PyObject *resultobj = 0;
26705 wxWindow *arg1 = (wxWindow *) 0 ;
26706 wxDateTime *arg2 = 0 ;
26707 wxEventType arg3 ;
26708 wxDateEvent *result = 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 void *argp2 = 0 ;
26712 int res2 = 0 ;
26713 int val3 ;
26714 int ecode3 = 0 ;
26715 PyObject * obj0 = 0 ;
26716 PyObject * obj1 = 0 ;
26717 PyObject * obj2 = 0 ;
26718 char * kwnames[] = {
26719 (char *) "win",(char *) "dt",(char *) "type", NULL
26720 };
26721
26722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26726 }
26727 arg1 = reinterpret_cast< wxWindow * >(argp1);
26728 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26729 if (!SWIG_IsOK(res2)) {
26730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26731 }
26732 if (!argp2) {
26733 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26734 }
26735 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26736 ecode3 = SWIG_AsVal_int(obj2, &val3);
26737 if (!SWIG_IsOK(ecode3)) {
26738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26739 }
26740 arg3 = static_cast< wxEventType >(val3);
26741 {
26742 PyThreadState* __tstate = wxPyBeginAllowThreads();
26743 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26744 wxPyEndAllowThreads(__tstate);
26745 if (PyErr_Occurred()) SWIG_fail;
26746 }
26747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 PyObject *resultobj = 0;
26756 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26757 wxDateTime *result = 0 ;
26758 void *argp1 = 0 ;
26759 int res1 = 0 ;
26760 PyObject *swig_obj[1] ;
26761
26762 if (!args) SWIG_fail;
26763 swig_obj[0] = args;
26764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26765 if (!SWIG_IsOK(res1)) {
26766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26767 }
26768 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26769 {
26770 PyThreadState* __tstate = wxPyBeginAllowThreads();
26771 {
26772 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26773 result = (wxDateTime *) &_result_ref;
26774 }
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = 0;
26787 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26788 wxDateTime *arg2 = 0 ;
26789 void *argp1 = 0 ;
26790 int res1 = 0 ;
26791 void *argp2 = 0 ;
26792 int res2 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 char * kwnames[] = {
26796 (char *) "self",(char *) "date", NULL
26797 };
26798
26799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26801 if (!SWIG_IsOK(res1)) {
26802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26803 }
26804 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26806 if (!SWIG_IsOK(res2)) {
26807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26808 }
26809 if (!argp2) {
26810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26811 }
26812 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 (arg1)->SetDate((wxDateTime const &)*arg2);
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 resultobj = SWIG_Py_Void();
26820 return resultobj;
26821 fail:
26822 return NULL;
26823 }
26824
26825
26826 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26827 PyObject *obj;
26828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26829 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26830 return SWIG_Py_Void();
26831 }
26832
26833 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26834 return SWIG_Python_InitShadowInstance(args);
26835 }
26836
26837 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26838 PyObject *resultobj = 0;
26839 wxPyApp *result = 0 ;
26840
26841 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26842 {
26843 PyThreadState* __tstate = wxPyBeginAllowThreads();
26844 result = (wxPyApp *)new_wxPyApp();
26845 wxPyEndAllowThreads(__tstate);
26846 if (PyErr_Occurred()) SWIG_fail;
26847 }
26848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26856 PyObject *resultobj = 0;
26857 wxPyApp *arg1 = (wxPyApp *) 0 ;
26858 void *argp1 = 0 ;
26859 int res1 = 0 ;
26860 PyObject *swig_obj[1] ;
26861
26862 if (!args) SWIG_fail;
26863 swig_obj[0] = args;
26864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26865 if (!SWIG_IsOK(res1)) {
26866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26867 }
26868 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 delete arg1;
26872
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 resultobj = SWIG_Py_Void();
26877 return resultobj;
26878 fail:
26879 return NULL;
26880 }
26881
26882
26883 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26884 PyObject *resultobj = 0;
26885 wxPyApp *arg1 = (wxPyApp *) 0 ;
26886 PyObject *arg2 = (PyObject *) 0 ;
26887 PyObject *arg3 = (PyObject *) 0 ;
26888 bool arg4 ;
26889 void *argp1 = 0 ;
26890 int res1 = 0 ;
26891 bool val4 ;
26892 int ecode4 = 0 ;
26893 PyObject * obj0 = 0 ;
26894 PyObject * obj1 = 0 ;
26895 PyObject * obj2 = 0 ;
26896 PyObject * obj3 = 0 ;
26897 char * kwnames[] = {
26898 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26899 };
26900
26901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26905 }
26906 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26907 arg2 = obj1;
26908 arg3 = obj2;
26909 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26910 if (!SWIG_IsOK(ecode4)) {
26911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26912 }
26913 arg4 = static_cast< bool >(val4);
26914 {
26915 PyThreadState* __tstate = wxPyBeginAllowThreads();
26916 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
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_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26928 PyObject *resultobj = 0;
26929 wxPyApp *arg1 = (wxPyApp *) 0 ;
26930 wxString result;
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_wxPyApp, 0 | 0 );
26938 if (!SWIG_IsOK(res1)) {
26939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26940 }
26941 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26942 {
26943 PyThreadState* __tstate = wxPyBeginAllowThreads();
26944 result = ((wxPyApp const *)arg1)->GetAppName();
26945 wxPyEndAllowThreads(__tstate);
26946 if (PyErr_Occurred()) SWIG_fail;
26947 }
26948 {
26949 #if wxUSE_UNICODE
26950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26951 #else
26952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26953 #endif
26954 }
26955 return resultobj;
26956 fail:
26957 return NULL;
26958 }
26959
26960
26961 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26962 PyObject *resultobj = 0;
26963 wxPyApp *arg1 = (wxPyApp *) 0 ;
26964 wxString *arg2 = 0 ;
26965 void *argp1 = 0 ;
26966 int res1 = 0 ;
26967 bool temp2 = false ;
26968 PyObject * obj0 = 0 ;
26969 PyObject * obj1 = 0 ;
26970 char * kwnames[] = {
26971 (char *) "self",(char *) "name", NULL
26972 };
26973
26974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26976 if (!SWIG_IsOK(res1)) {
26977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26978 }
26979 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26980 {
26981 arg2 = wxString_in_helper(obj1);
26982 if (arg2 == NULL) SWIG_fail;
26983 temp2 = true;
26984 }
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 (arg1)->SetAppName((wxString const &)*arg2);
26988 wxPyEndAllowThreads(__tstate);
26989 if (PyErr_Occurred()) SWIG_fail;
26990 }
26991 resultobj = SWIG_Py_Void();
26992 {
26993 if (temp2)
26994 delete arg2;
26995 }
26996 return resultobj;
26997 fail:
26998 {
26999 if (temp2)
27000 delete arg2;
27001 }
27002 return NULL;
27003 }
27004
27005
27006 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27007 PyObject *resultobj = 0;
27008 wxPyApp *arg1 = (wxPyApp *) 0 ;
27009 wxString result;
27010 void *argp1 = 0 ;
27011 int res1 = 0 ;
27012 PyObject *swig_obj[1] ;
27013
27014 if (!args) SWIG_fail;
27015 swig_obj[0] = args;
27016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27017 if (!SWIG_IsOK(res1)) {
27018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27019 }
27020 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 result = ((wxPyApp const *)arg1)->GetClassName();
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 {
27028 #if wxUSE_UNICODE
27029 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27030 #else
27031 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27032 #endif
27033 }
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj = 0;
27042 wxPyApp *arg1 = (wxPyApp *) 0 ;
27043 wxString *arg2 = 0 ;
27044 void *argp1 = 0 ;
27045 int res1 = 0 ;
27046 bool temp2 = false ;
27047 PyObject * obj0 = 0 ;
27048 PyObject * obj1 = 0 ;
27049 char * kwnames[] = {
27050 (char *) "self",(char *) "name", NULL
27051 };
27052
27053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27055 if (!SWIG_IsOK(res1)) {
27056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27057 }
27058 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27059 {
27060 arg2 = wxString_in_helper(obj1);
27061 if (arg2 == NULL) SWIG_fail;
27062 temp2 = true;
27063 }
27064 {
27065 PyThreadState* __tstate = wxPyBeginAllowThreads();
27066 (arg1)->SetClassName((wxString const &)*arg2);
27067 wxPyEndAllowThreads(__tstate);
27068 if (PyErr_Occurred()) SWIG_fail;
27069 }
27070 resultobj = SWIG_Py_Void();
27071 {
27072 if (temp2)
27073 delete arg2;
27074 }
27075 return resultobj;
27076 fail:
27077 {
27078 if (temp2)
27079 delete arg2;
27080 }
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27086 PyObject *resultobj = 0;
27087 wxPyApp *arg1 = (wxPyApp *) 0 ;
27088 wxString *result = 0 ;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 PyObject *swig_obj[1] ;
27092
27093 if (!args) SWIG_fail;
27094 swig_obj[0] = args;
27095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27098 }
27099 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27100 {
27101 PyThreadState* __tstate = wxPyBeginAllowThreads();
27102 {
27103 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27104 result = (wxString *) &_result_ref;
27105 }
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 #if wxUSE_UNICODE
27111 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27112 #else
27113 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27114 #endif
27115 }
27116 return resultobj;
27117 fail:
27118 return NULL;
27119 }
27120
27121
27122 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27123 PyObject *resultobj = 0;
27124 wxPyApp *arg1 = (wxPyApp *) 0 ;
27125 wxString *arg2 = 0 ;
27126 void *argp1 = 0 ;
27127 int res1 = 0 ;
27128 bool temp2 = false ;
27129 PyObject * obj0 = 0 ;
27130 PyObject * obj1 = 0 ;
27131 char * kwnames[] = {
27132 (char *) "self",(char *) "name", NULL
27133 };
27134
27135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27137 if (!SWIG_IsOK(res1)) {
27138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27139 }
27140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27141 {
27142 arg2 = wxString_in_helper(obj1);
27143 if (arg2 == NULL) SWIG_fail;
27144 temp2 = true;
27145 }
27146 {
27147 PyThreadState* __tstate = wxPyBeginAllowThreads();
27148 (arg1)->SetVendorName((wxString const &)*arg2);
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 resultobj = SWIG_Py_Void();
27153 {
27154 if (temp2)
27155 delete arg2;
27156 }
27157 return resultobj;
27158 fail:
27159 {
27160 if (temp2)
27161 delete arg2;
27162 }
27163 return NULL;
27164 }
27165
27166
27167 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27168 PyObject *resultobj = 0;
27169 wxPyApp *arg1 = (wxPyApp *) 0 ;
27170 wxAppTraits *result = 0 ;
27171 void *argp1 = 0 ;
27172 int res1 = 0 ;
27173 PyObject *swig_obj[1] ;
27174
27175 if (!args) SWIG_fail;
27176 swig_obj[0] = args;
27177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27178 if (!SWIG_IsOK(res1)) {
27179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27180 }
27181 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27182 {
27183 PyThreadState* __tstate = wxPyBeginAllowThreads();
27184 result = (wxAppTraits *)(arg1)->GetTraits();
27185 wxPyEndAllowThreads(__tstate);
27186 if (PyErr_Occurred()) SWIG_fail;
27187 }
27188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27189 return resultobj;
27190 fail:
27191 return NULL;
27192 }
27193
27194
27195 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27196 PyObject *resultobj = 0;
27197 wxPyApp *arg1 = (wxPyApp *) 0 ;
27198 void *argp1 = 0 ;
27199 int res1 = 0 ;
27200 PyObject *swig_obj[1] ;
27201
27202 if (!args) SWIG_fail;
27203 swig_obj[0] = args;
27204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27205 if (!SWIG_IsOK(res1)) {
27206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27207 }
27208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 (arg1)->ProcessPendingEvents();
27212 wxPyEndAllowThreads(__tstate);
27213 if (PyErr_Occurred()) SWIG_fail;
27214 }
27215 resultobj = SWIG_Py_Void();
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27223 PyObject *resultobj = 0;
27224 wxPyApp *arg1 = (wxPyApp *) 0 ;
27225 bool arg2 = (bool) false ;
27226 bool result;
27227 void *argp1 = 0 ;
27228 int res1 = 0 ;
27229 bool val2 ;
27230 int ecode2 = 0 ;
27231 PyObject * obj0 = 0 ;
27232 PyObject * obj1 = 0 ;
27233 char * kwnames[] = {
27234 (char *) "self",(char *) "onlyIfNeeded", NULL
27235 };
27236
27237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27239 if (!SWIG_IsOK(res1)) {
27240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27241 }
27242 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27243 if (obj1) {
27244 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27245 if (!SWIG_IsOK(ecode2)) {
27246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27247 }
27248 arg2 = static_cast< bool >(val2);
27249 }
27250 {
27251 PyThreadState* __tstate = wxPyBeginAllowThreads();
27252 result = (bool)(arg1)->Yield(arg2);
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27258 }
27259 return resultobj;
27260 fail:
27261 return NULL;
27262 }
27263
27264
27265 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27266 PyObject *resultobj = 0;
27267 wxPyApp *arg1 = (wxPyApp *) 0 ;
27268 void *argp1 = 0 ;
27269 int res1 = 0 ;
27270 PyObject *swig_obj[1] ;
27271
27272 if (!args) SWIG_fail;
27273 swig_obj[0] = args;
27274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27275 if (!SWIG_IsOK(res1)) {
27276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27277 }
27278 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27279 {
27280 PyThreadState* __tstate = wxPyBeginAllowThreads();
27281 (arg1)->WakeUpIdle();
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 resultobj = SWIG_Py_Void();
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27293 PyObject *resultobj = 0;
27294 bool result;
27295
27296 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 result = (bool)wxPyApp::IsMainLoopRunning();
27300 wxPyEndAllowThreads(__tstate);
27301 if (PyErr_Occurred()) SWIG_fail;
27302 }
27303 {
27304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27305 }
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27313 PyObject *resultobj = 0;
27314 wxPyApp *arg1 = (wxPyApp *) 0 ;
27315 int result;
27316 void *argp1 = 0 ;
27317 int res1 = 0 ;
27318 PyObject *swig_obj[1] ;
27319
27320 if (!args) SWIG_fail;
27321 swig_obj[0] = args;
27322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27323 if (!SWIG_IsOK(res1)) {
27324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27325 }
27326 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = (int)(arg1)->MainLoop();
27330 wxPyEndAllowThreads(__tstate);
27331 if (PyErr_Occurred()) SWIG_fail;
27332 }
27333 resultobj = SWIG_From_int(static_cast< int >(result));
27334 return resultobj;
27335 fail:
27336 return NULL;
27337 }
27338
27339
27340 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27341 PyObject *resultobj = 0;
27342 wxPyApp *arg1 = (wxPyApp *) 0 ;
27343 void *argp1 = 0 ;
27344 int res1 = 0 ;
27345 PyObject *swig_obj[1] ;
27346
27347 if (!args) SWIG_fail;
27348 swig_obj[0] = args;
27349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27350 if (!SWIG_IsOK(res1)) {
27351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27352 }
27353 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 (arg1)->Exit();
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_Py_Void();
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 void *argp1 = 0 ;
27371 int res1 = 0 ;
27372 PyObject *swig_obj[1] ;
27373
27374 if (!args) SWIG_fail;
27375 swig_obj[0] = args;
27376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27377 if (!SWIG_IsOK(res1)) {
27378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27379 }
27380 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27381 {
27382 PyThreadState* __tstate = wxPyBeginAllowThreads();
27383 (arg1)->ExitMainLoop();
27384 wxPyEndAllowThreads(__tstate);
27385 if (PyErr_Occurred()) SWIG_fail;
27386 }
27387 resultobj = SWIG_Py_Void();
27388 return resultobj;
27389 fail:
27390 return NULL;
27391 }
27392
27393
27394 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27395 PyObject *resultobj = 0;
27396 wxPyApp *arg1 = (wxPyApp *) 0 ;
27397 bool result;
27398 void *argp1 = 0 ;
27399 int res1 = 0 ;
27400 PyObject *swig_obj[1] ;
27401
27402 if (!args) SWIG_fail;
27403 swig_obj[0] = args;
27404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27405 if (!SWIG_IsOK(res1)) {
27406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27407 }
27408 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27409 {
27410 PyThreadState* __tstate = wxPyBeginAllowThreads();
27411 result = (bool)(arg1)->Pending();
27412 wxPyEndAllowThreads(__tstate);
27413 if (PyErr_Occurred()) SWIG_fail;
27414 }
27415 {
27416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27417 }
27418 return resultobj;
27419 fail:
27420 return NULL;
27421 }
27422
27423
27424 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 PyObject *resultobj = 0;
27426 wxPyApp *arg1 = (wxPyApp *) 0 ;
27427 bool result;
27428 void *argp1 = 0 ;
27429 int res1 = 0 ;
27430 PyObject *swig_obj[1] ;
27431
27432 if (!args) SWIG_fail;
27433 swig_obj[0] = args;
27434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27435 if (!SWIG_IsOK(res1)) {
27436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27437 }
27438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 result = (bool)(arg1)->Dispatch();
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 {
27446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27447 }
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxPyApp *arg1 = (wxPyApp *) 0 ;
27457 bool result;
27458 void *argp1 = 0 ;
27459 int res1 = 0 ;
27460 PyObject *swig_obj[1] ;
27461
27462 if (!args) SWIG_fail;
27463 swig_obj[0] = args;
27464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27465 if (!SWIG_IsOK(res1)) {
27466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27467 }
27468 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 result = (bool)(arg1)->ProcessIdle();
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 {
27476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27477 }
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27485 PyObject *resultobj = 0;
27486 wxPyApp *arg1 = (wxPyApp *) 0 ;
27487 wxWindow *arg2 = (wxWindow *) 0 ;
27488 wxIdleEvent *arg3 = 0 ;
27489 bool result;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 void *argp2 = 0 ;
27493 int res2 = 0 ;
27494 void *argp3 = 0 ;
27495 int res3 = 0 ;
27496 PyObject * obj0 = 0 ;
27497 PyObject * obj1 = 0 ;
27498 PyObject * obj2 = 0 ;
27499 char * kwnames[] = {
27500 (char *) "self",(char *) "win",(char *) "event", NULL
27501 };
27502
27503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27505 if (!SWIG_IsOK(res1)) {
27506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27507 }
27508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27510 if (!SWIG_IsOK(res2)) {
27511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27512 }
27513 arg2 = reinterpret_cast< wxWindow * >(argp2);
27514 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27515 if (!SWIG_IsOK(res3)) {
27516 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27517 }
27518 if (!argp3) {
27519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27520 }
27521 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27522 {
27523 PyThreadState* __tstate = wxPyBeginAllowThreads();
27524 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 {
27529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27530 }
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27538 PyObject *resultobj = 0;
27539 wxPyApp *arg1 = (wxPyApp *) 0 ;
27540 bool result;
27541 void *argp1 = 0 ;
27542 int res1 = 0 ;
27543 PyObject *swig_obj[1] ;
27544
27545 if (!args) SWIG_fail;
27546 swig_obj[0] = args;
27547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27548 if (!SWIG_IsOK(res1)) {
27549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27550 }
27551 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 result = (bool)((wxPyApp const *)arg1)->IsActive();
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 {
27559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27560 }
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27568 PyObject *resultobj = 0;
27569 wxPyApp *arg1 = (wxPyApp *) 0 ;
27570 wxWindow *arg2 = (wxWindow *) 0 ;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 void *argp2 = 0 ;
27574 int res2 = 0 ;
27575 PyObject * obj0 = 0 ;
27576 PyObject * obj1 = 0 ;
27577 char * kwnames[] = {
27578 (char *) "self",(char *) "win", NULL
27579 };
27580
27581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27583 if (!SWIG_IsOK(res1)) {
27584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27585 }
27586 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27588 if (!SWIG_IsOK(res2)) {
27589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27590 }
27591 arg2 = reinterpret_cast< wxWindow * >(argp2);
27592 {
27593 PyThreadState* __tstate = wxPyBeginAllowThreads();
27594 (arg1)->SetTopWindow(arg2);
27595 wxPyEndAllowThreads(__tstate);
27596 if (PyErr_Occurred()) SWIG_fail;
27597 }
27598 resultobj = SWIG_Py_Void();
27599 return resultobj;
27600 fail:
27601 return NULL;
27602 }
27603
27604
27605 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27606 PyObject *resultobj = 0;
27607 wxPyApp *arg1 = (wxPyApp *) 0 ;
27608 wxWindow *result = 0 ;
27609 void *argp1 = 0 ;
27610 int res1 = 0 ;
27611 PyObject *swig_obj[1] ;
27612
27613 if (!args) SWIG_fail;
27614 swig_obj[0] = args;
27615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27616 if (!SWIG_IsOK(res1)) {
27617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27618 }
27619 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27623 wxPyEndAllowThreads(__tstate);
27624 if (PyErr_Occurred()) SWIG_fail;
27625 }
27626 {
27627 resultobj = wxPyMake_wxObject(result, (bool)0);
27628 }
27629 return resultobj;
27630 fail:
27631 return NULL;
27632 }
27633
27634
27635 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27636 PyObject *resultobj = 0;
27637 wxPyApp *arg1 = (wxPyApp *) 0 ;
27638 bool arg2 ;
27639 void *argp1 = 0 ;
27640 int res1 = 0 ;
27641 bool val2 ;
27642 int ecode2 = 0 ;
27643 PyObject * obj0 = 0 ;
27644 PyObject * obj1 = 0 ;
27645 char * kwnames[] = {
27646 (char *) "self",(char *) "flag", NULL
27647 };
27648
27649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27651 if (!SWIG_IsOK(res1)) {
27652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27653 }
27654 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27656 if (!SWIG_IsOK(ecode2)) {
27657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27658 }
27659 arg2 = static_cast< bool >(val2);
27660 {
27661 PyThreadState* __tstate = wxPyBeginAllowThreads();
27662 (arg1)->SetExitOnFrameDelete(arg2);
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 resultobj = SWIG_Py_Void();
27667 return resultobj;
27668 fail:
27669 return NULL;
27670 }
27671
27672
27673 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27674 PyObject *resultobj = 0;
27675 wxPyApp *arg1 = (wxPyApp *) 0 ;
27676 bool result;
27677 void *argp1 = 0 ;
27678 int res1 = 0 ;
27679 PyObject *swig_obj[1] ;
27680
27681 if (!args) SWIG_fail;
27682 swig_obj[0] = args;
27683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27684 if (!SWIG_IsOK(res1)) {
27685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27686 }
27687 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27688 {
27689 PyThreadState* __tstate = wxPyBeginAllowThreads();
27690 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 {
27695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27696 }
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj = 0;
27705 wxPyApp *arg1 = (wxPyApp *) 0 ;
27706 bool arg2 ;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 bool val2 ;
27710 int ecode2 = 0 ;
27711 PyObject * obj0 = 0 ;
27712 PyObject * obj1 = 0 ;
27713 char * kwnames[] = {
27714 (char *) "self",(char *) "flag", NULL
27715 };
27716
27717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27719 if (!SWIG_IsOK(res1)) {
27720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27721 }
27722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27723 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27724 if (!SWIG_IsOK(ecode2)) {
27725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27726 }
27727 arg2 = static_cast< bool >(val2);
27728 {
27729 PyThreadState* __tstate = wxPyBeginAllowThreads();
27730 (arg1)->SetUseBestVisual(arg2);
27731 wxPyEndAllowThreads(__tstate);
27732 if (PyErr_Occurred()) SWIG_fail;
27733 }
27734 resultobj = SWIG_Py_Void();
27735 return resultobj;
27736 fail:
27737 return NULL;
27738 }
27739
27740
27741 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27742 PyObject *resultobj = 0;
27743 wxPyApp *arg1 = (wxPyApp *) 0 ;
27744 bool result;
27745 void *argp1 = 0 ;
27746 int res1 = 0 ;
27747 PyObject *swig_obj[1] ;
27748
27749 if (!args) SWIG_fail;
27750 swig_obj[0] = args;
27751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27752 if (!SWIG_IsOK(res1)) {
27753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27754 }
27755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 {
27763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27764 }
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj = 0;
27773 wxPyApp *arg1 = (wxPyApp *) 0 ;
27774 int arg2 ;
27775 void *argp1 = 0 ;
27776 int res1 = 0 ;
27777 int val2 ;
27778 int ecode2 = 0 ;
27779 PyObject * obj0 = 0 ;
27780 PyObject * obj1 = 0 ;
27781 char * kwnames[] = {
27782 (char *) "self",(char *) "mode", NULL
27783 };
27784
27785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27787 if (!SWIG_IsOK(res1)) {
27788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27789 }
27790 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27791 ecode2 = SWIG_AsVal_int(obj1, &val2);
27792 if (!SWIG_IsOK(ecode2)) {
27793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27794 }
27795 arg2 = static_cast< int >(val2);
27796 {
27797 PyThreadState* __tstate = wxPyBeginAllowThreads();
27798 (arg1)->SetPrintMode(arg2);
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 resultobj = SWIG_Py_Void();
27803 return resultobj;
27804 fail:
27805 return NULL;
27806 }
27807
27808
27809 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 PyObject *resultobj = 0;
27811 wxPyApp *arg1 = (wxPyApp *) 0 ;
27812 int result;
27813 void *argp1 = 0 ;
27814 int res1 = 0 ;
27815 PyObject *swig_obj[1] ;
27816
27817 if (!args) SWIG_fail;
27818 swig_obj[0] = args;
27819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27820 if (!SWIG_IsOK(res1)) {
27821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27822 }
27823 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27827 wxPyEndAllowThreads(__tstate);
27828 if (PyErr_Occurred()) SWIG_fail;
27829 }
27830 resultobj = SWIG_From_int(static_cast< int >(result));
27831 return resultobj;
27832 fail:
27833 return NULL;
27834 }
27835
27836
27837 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27838 PyObject *resultobj = 0;
27839 wxPyApp *arg1 = (wxPyApp *) 0 ;
27840 int arg2 ;
27841 void *argp1 = 0 ;
27842 int res1 = 0 ;
27843 int val2 ;
27844 int ecode2 = 0 ;
27845 PyObject * obj0 = 0 ;
27846 PyObject * obj1 = 0 ;
27847 char * kwnames[] = {
27848 (char *) "self",(char *) "mode", NULL
27849 };
27850
27851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27855 }
27856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27857 ecode2 = SWIG_AsVal_int(obj1, &val2);
27858 if (!SWIG_IsOK(ecode2)) {
27859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27860 }
27861 arg2 = static_cast< int >(val2);
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 (arg1)->SetAssertMode(arg2);
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 resultobj = SWIG_Py_Void();
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27876 PyObject *resultobj = 0;
27877 wxPyApp *arg1 = (wxPyApp *) 0 ;
27878 int result;
27879 void *argp1 = 0 ;
27880 int res1 = 0 ;
27881 PyObject *swig_obj[1] ;
27882
27883 if (!args) SWIG_fail;
27884 swig_obj[0] = args;
27885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27886 if (!SWIG_IsOK(res1)) {
27887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27888 }
27889 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 result = (int)(arg1)->GetAssertMode();
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = SWIG_From_int(static_cast< int >(result));
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27904 PyObject *resultobj = 0;
27905 bool result;
27906
27907 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27908 {
27909 PyThreadState* __tstate = wxPyBeginAllowThreads();
27910 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27911 wxPyEndAllowThreads(__tstate);
27912 if (PyErr_Occurred()) SWIG_fail;
27913 }
27914 {
27915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27916 }
27917 return resultobj;
27918 fail:
27919 return NULL;
27920 }
27921
27922
27923 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27924 PyObject *resultobj = 0;
27925 long result;
27926
27927 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 result = (long)wxPyApp::GetMacAboutMenuItemId();
27931 wxPyEndAllowThreads(__tstate);
27932 if (PyErr_Occurred()) SWIG_fail;
27933 }
27934 resultobj = SWIG_From_long(static_cast< long >(result));
27935 return resultobj;
27936 fail:
27937 return NULL;
27938 }
27939
27940
27941 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27942 PyObject *resultobj = 0;
27943 long result;
27944
27945 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27946 {
27947 PyThreadState* __tstate = wxPyBeginAllowThreads();
27948 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 resultobj = SWIG_From_long(static_cast< long >(result));
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27960 PyObject *resultobj = 0;
27961 long result;
27962
27963 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 result = (long)wxPyApp::GetMacExitMenuItemId();
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 resultobj = SWIG_From_long(static_cast< long >(result));
27971 return resultobj;
27972 fail:
27973 return NULL;
27974 }
27975
27976
27977 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27978 PyObject *resultobj = 0;
27979 wxString result;
27980
27981 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27982 {
27983 PyThreadState* __tstate = wxPyBeginAllowThreads();
27984 result = wxPyApp::GetMacHelpMenuTitleName();
27985 wxPyEndAllowThreads(__tstate);
27986 if (PyErr_Occurred()) SWIG_fail;
27987 }
27988 {
27989 #if wxUSE_UNICODE
27990 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27991 #else
27992 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27993 #endif
27994 }
27995 return resultobj;
27996 fail:
27997 return NULL;
27998 }
27999
28000
28001 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28002 PyObject *resultobj = 0;
28003 bool arg1 ;
28004 bool val1 ;
28005 int ecode1 = 0 ;
28006 PyObject * obj0 = 0 ;
28007 char * kwnames[] = {
28008 (char *) "val", NULL
28009 };
28010
28011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28012 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28013 if (!SWIG_IsOK(ecode1)) {
28014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28015 }
28016 arg1 = static_cast< bool >(val1);
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 resultobj = SWIG_Py_Void();
28024 return resultobj;
28025 fail:
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28031 PyObject *resultobj = 0;
28032 long arg1 ;
28033 long val1 ;
28034 int ecode1 = 0 ;
28035 PyObject * obj0 = 0 ;
28036 char * kwnames[] = {
28037 (char *) "val", NULL
28038 };
28039
28040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28041 ecode1 = SWIG_AsVal_long(obj0, &val1);
28042 if (!SWIG_IsOK(ecode1)) {
28043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28044 }
28045 arg1 = static_cast< long >(val1);
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 wxPyApp::SetMacAboutMenuItemId(arg1);
28049 wxPyEndAllowThreads(__tstate);
28050 if (PyErr_Occurred()) SWIG_fail;
28051 }
28052 resultobj = SWIG_Py_Void();
28053 return resultobj;
28054 fail:
28055 return NULL;
28056 }
28057
28058
28059 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28060 PyObject *resultobj = 0;
28061 long arg1 ;
28062 long val1 ;
28063 int ecode1 = 0 ;
28064 PyObject * obj0 = 0 ;
28065 char * kwnames[] = {
28066 (char *) "val", NULL
28067 };
28068
28069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28070 ecode1 = SWIG_AsVal_long(obj0, &val1);
28071 if (!SWIG_IsOK(ecode1)) {
28072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28073 }
28074 arg1 = static_cast< long >(val1);
28075 {
28076 PyThreadState* __tstate = wxPyBeginAllowThreads();
28077 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28078 wxPyEndAllowThreads(__tstate);
28079 if (PyErr_Occurred()) SWIG_fail;
28080 }
28081 resultobj = SWIG_Py_Void();
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = 0;
28090 long arg1 ;
28091 long val1 ;
28092 int ecode1 = 0 ;
28093 PyObject * obj0 = 0 ;
28094 char * kwnames[] = {
28095 (char *) "val", NULL
28096 };
28097
28098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28099 ecode1 = SWIG_AsVal_long(obj0, &val1);
28100 if (!SWIG_IsOK(ecode1)) {
28101 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28102 }
28103 arg1 = static_cast< long >(val1);
28104 {
28105 PyThreadState* __tstate = wxPyBeginAllowThreads();
28106 wxPyApp::SetMacExitMenuItemId(arg1);
28107 wxPyEndAllowThreads(__tstate);
28108 if (PyErr_Occurred()) SWIG_fail;
28109 }
28110 resultobj = SWIG_Py_Void();
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28118 PyObject *resultobj = 0;
28119 wxString *arg1 = 0 ;
28120 bool temp1 = false ;
28121 PyObject * obj0 = 0 ;
28122 char * kwnames[] = {
28123 (char *) "val", NULL
28124 };
28125
28126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28127 {
28128 arg1 = wxString_in_helper(obj0);
28129 if (arg1 == NULL) SWIG_fail;
28130 temp1 = true;
28131 }
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28135 wxPyEndAllowThreads(__tstate);
28136 if (PyErr_Occurred()) SWIG_fail;
28137 }
28138 resultobj = SWIG_Py_Void();
28139 {
28140 if (temp1)
28141 delete arg1;
28142 }
28143 return resultobj;
28144 fail:
28145 {
28146 if (temp1)
28147 delete arg1;
28148 }
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 PyObject *resultobj = 0;
28155 wxPyApp *arg1 = (wxPyApp *) 0 ;
28156 void *argp1 = 0 ;
28157 int res1 = 0 ;
28158 PyObject *swig_obj[1] ;
28159
28160 if (!args) SWIG_fail;
28161 swig_obj[0] = args;
28162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28163 if (!SWIG_IsOK(res1)) {
28164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28165 }
28166 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28167 {
28168 PyThreadState* __tstate = wxPyBeginAllowThreads();
28169 (arg1)->_BootstrapApp();
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 resultobj = SWIG_Py_Void();
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28181 PyObject *resultobj = 0;
28182 int result;
28183
28184 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 result = (int)wxPyApp::GetComCtl32Version();
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_From_int(static_cast< int >(result));
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28199 PyObject *obj;
28200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28201 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28202 return SWIG_Py_Void();
28203 }
28204
28205 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28206 return SWIG_Python_InitShadowInstance(args);
28207 }
28208
28209 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28210 PyObject *resultobj = 0;
28211
28212 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 wxExit();
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_Py_Void();
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28227 PyObject *resultobj = 0;
28228 bool result;
28229
28230 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28231 {
28232 PyThreadState* __tstate = wxPyBeginAllowThreads();
28233 result = (bool)wxYield();
28234 wxPyEndAllowThreads(__tstate);
28235 if (PyErr_Occurred()) SWIG_fail;
28236 }
28237 {
28238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28239 }
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28247 PyObject *resultobj = 0;
28248 bool result;
28249
28250 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28251 {
28252 PyThreadState* __tstate = wxPyBeginAllowThreads();
28253 result = (bool)wxYieldIfNeeded();
28254 wxPyEndAllowThreads(__tstate);
28255 if (PyErr_Occurred()) SWIG_fail;
28256 }
28257 {
28258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28259 }
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = 0;
28268 wxWindow *arg1 = (wxWindow *) NULL ;
28269 bool arg2 = (bool) false ;
28270 bool result;
28271 void *argp1 = 0 ;
28272 int res1 = 0 ;
28273 bool val2 ;
28274 int ecode2 = 0 ;
28275 PyObject * obj0 = 0 ;
28276 PyObject * obj1 = 0 ;
28277 char * kwnames[] = {
28278 (char *) "win",(char *) "onlyIfNeeded", NULL
28279 };
28280
28281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28282 if (obj0) {
28283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28284 if (!SWIG_IsOK(res1)) {
28285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28286 }
28287 arg1 = reinterpret_cast< wxWindow * >(argp1);
28288 }
28289 if (obj1) {
28290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28291 if (!SWIG_IsOK(ecode2)) {
28292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28293 }
28294 arg2 = static_cast< bool >(val2);
28295 }
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 result = (bool)wxSafeYield(arg1,arg2);
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 {
28303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28304 }
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 PyObject *resultobj = 0;
28313
28314 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28315 {
28316 PyThreadState* __tstate = wxPyBeginAllowThreads();
28317 wxWakeUpIdle();
28318 wxPyEndAllowThreads(__tstate);
28319 if (PyErr_Occurred()) SWIG_fail;
28320 }
28321 resultobj = SWIG_Py_Void();
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj = 0;
28330 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28331 wxEvent *arg2 = 0 ;
28332 void *argp1 = 0 ;
28333 int res1 = 0 ;
28334 void *argp2 = 0 ;
28335 int res2 = 0 ;
28336 PyObject * obj0 = 0 ;
28337 PyObject * obj1 = 0 ;
28338 char * kwnames[] = {
28339 (char *) "dest",(char *) "event", NULL
28340 };
28341
28342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28344 if (!SWIG_IsOK(res1)) {
28345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28346 }
28347 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28348 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28349 if (!SWIG_IsOK(res2)) {
28350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28351 }
28352 if (!argp2) {
28353 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28354 }
28355 arg2 = reinterpret_cast< wxEvent * >(argp2);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 wxPostEvent(arg1,*arg2);
28359 wxPyEndAllowThreads(__tstate);
28360 if (PyErr_Occurred()) SWIG_fail;
28361 }
28362 resultobj = SWIG_Py_Void();
28363 return resultobj;
28364 fail:
28365 return NULL;
28366 }
28367
28368
28369 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 PyObject *resultobj = 0;
28371
28372 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 wxApp_CleanUp();
28376 wxPyEndAllowThreads(__tstate);
28377 if (PyErr_Occurred()) SWIG_fail;
28378 }
28379 resultobj = SWIG_Py_Void();
28380 return resultobj;
28381 fail:
28382 return NULL;
28383 }
28384
28385
28386 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28387 PyObject *resultobj = 0;
28388 wxPyApp *result = 0 ;
28389
28390 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28391 {
28392 PyThreadState* __tstate = wxPyBeginAllowThreads();
28393 result = (wxPyApp *)wxPyGetApp();
28394 wxPyEndAllowThreads(__tstate);
28395 if (PyErr_Occurred()) SWIG_fail;
28396 }
28397 {
28398 resultobj = wxPyMake_wxObject(result, 0);
28399 }
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj = 0;
28408 char *arg1 = (char *) 0 ;
28409 int res1 ;
28410 char *buf1 = 0 ;
28411 int alloc1 = 0 ;
28412 PyObject * obj0 = 0 ;
28413 char * kwnames[] = {
28414 (char *) "encoding", NULL
28415 };
28416
28417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28418 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28419 if (!SWIG_IsOK(res1)) {
28420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28421 }
28422 arg1 = buf1;
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 wxSetDefaultPyEncoding((char const *)arg1);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_Py_Void();
28430 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28431 return resultobj;
28432 fail:
28433 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 char *result = 0 ;
28441
28442 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 result = (char *)wxGetDefaultPyEncoding();
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 resultobj = SWIG_FromCharPtr(result);
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28457 PyObject *resultobj = 0;
28458 wxEventLoop *result = 0 ;
28459
28460 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (wxEventLoop *)new wxEventLoop();
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28477 void *argp1 = 0 ;
28478 int res1 = 0 ;
28479 PyObject *swig_obj[1] ;
28480
28481 if (!args) SWIG_fail;
28482 swig_obj[0] = args;
28483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28484 if (!SWIG_IsOK(res1)) {
28485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28486 }
28487 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 delete arg1;
28491
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 resultobj = SWIG_Py_Void();
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28503 PyObject *resultobj = 0;
28504 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28505 int result;
28506 void *argp1 = 0 ;
28507 int res1 = 0 ;
28508 PyObject *swig_obj[1] ;
28509
28510 if (!args) SWIG_fail;
28511 swig_obj[0] = args;
28512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28513 if (!SWIG_IsOK(res1)) {
28514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28515 }
28516 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28517 {
28518 PyThreadState* __tstate = wxPyBeginAllowThreads();
28519 result = (int)(arg1)->Run();
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 resultobj = SWIG_From_int(static_cast< int >(result));
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj = 0;
28532 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28533 int arg2 = (int) 0 ;
28534 void *argp1 = 0 ;
28535 int res1 = 0 ;
28536 int val2 ;
28537 int ecode2 = 0 ;
28538 PyObject * obj0 = 0 ;
28539 PyObject * obj1 = 0 ;
28540 char * kwnames[] = {
28541 (char *) "self",(char *) "rc", NULL
28542 };
28543
28544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28546 if (!SWIG_IsOK(res1)) {
28547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28548 }
28549 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28550 if (obj1) {
28551 ecode2 = SWIG_AsVal_int(obj1, &val2);
28552 if (!SWIG_IsOK(ecode2)) {
28553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28554 }
28555 arg2 = static_cast< int >(val2);
28556 }
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 (arg1)->Exit(arg2);
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 resultobj = SWIG_Py_Void();
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28571 PyObject *resultobj = 0;
28572 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28573 bool result;
28574 void *argp1 = 0 ;
28575 int res1 = 0 ;
28576 PyObject *swig_obj[1] ;
28577
28578 if (!args) SWIG_fail;
28579 swig_obj[0] = args;
28580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28581 if (!SWIG_IsOK(res1)) {
28582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28583 }
28584 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28585 {
28586 PyThreadState* __tstate = wxPyBeginAllowThreads();
28587 result = (bool)((wxEventLoop const *)arg1)->Pending();
28588 wxPyEndAllowThreads(__tstate);
28589 if (PyErr_Occurred()) SWIG_fail;
28590 }
28591 {
28592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28593 }
28594 return resultobj;
28595 fail:
28596 return NULL;
28597 }
28598
28599
28600 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28601 PyObject *resultobj = 0;
28602 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28603 bool result;
28604 void *argp1 = 0 ;
28605 int res1 = 0 ;
28606 PyObject *swig_obj[1] ;
28607
28608 if (!args) SWIG_fail;
28609 swig_obj[0] = args;
28610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28611 if (!SWIG_IsOK(res1)) {
28612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28613 }
28614 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28615 {
28616 PyThreadState* __tstate = wxPyBeginAllowThreads();
28617 result = (bool)(arg1)->Dispatch();
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 {
28622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28623 }
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28631 PyObject *resultobj = 0;
28632 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28633 bool result;
28634 void *argp1 = 0 ;
28635 int res1 = 0 ;
28636 PyObject *swig_obj[1] ;
28637
28638 if (!args) SWIG_fail;
28639 swig_obj[0] = args;
28640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28641 if (!SWIG_IsOK(res1)) {
28642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28643 }
28644 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 {
28652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28653 }
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662 wxEventLoop *result = 0 ;
28663
28664 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28665 {
28666 PyThreadState* __tstate = wxPyBeginAllowThreads();
28667 result = (wxEventLoop *)wxEventLoop::GetActive();
28668 wxPyEndAllowThreads(__tstate);
28669 if (PyErr_Occurred()) SWIG_fail;
28670 }
28671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28672 return resultobj;
28673 fail:
28674 return NULL;
28675 }
28676
28677
28678 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28679 PyObject *resultobj = 0;
28680 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28681 void *argp1 = 0 ;
28682 int res1 = 0 ;
28683 PyObject * obj0 = 0 ;
28684 char * kwnames[] = {
28685 (char *) "loop", NULL
28686 };
28687
28688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28690 if (!SWIG_IsOK(res1)) {
28691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28692 }
28693 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 wxEventLoop::SetActive(arg1);
28697 wxPyEndAllowThreads(__tstate);
28698 if (PyErr_Occurred()) SWIG_fail;
28699 }
28700 resultobj = SWIG_Py_Void();
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28708 PyObject *obj;
28709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28710 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28711 return SWIG_Py_Void();
28712 }
28713
28714 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 return SWIG_Python_InitShadowInstance(args);
28716 }
28717
28718 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj = 0;
28720 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28721 wxEventLoopActivator *result = 0 ;
28722 void *argp1 = 0 ;
28723 int res1 = 0 ;
28724 PyObject * obj0 = 0 ;
28725 char * kwnames[] = {
28726 (char *) "evtLoop", NULL
28727 };
28728
28729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28731 if (!SWIG_IsOK(res1)) {
28732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28733 }
28734 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28735 {
28736 PyThreadState* __tstate = wxPyBeginAllowThreads();
28737 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28738 wxPyEndAllowThreads(__tstate);
28739 if (PyErr_Occurred()) SWIG_fail;
28740 }
28741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28751 void *argp1 = 0 ;
28752 int res1 = 0 ;
28753 PyObject *swig_obj[1] ;
28754
28755 if (!args) SWIG_fail;
28756 swig_obj[0] = args;
28757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28760 }
28761 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 delete arg1;
28765
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_Py_Void();
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *obj;
28778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28779 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28780 return SWIG_Py_Void();
28781 }
28782
28783 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28784 return SWIG_Python_InitShadowInstance(args);
28785 }
28786
28787 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj = 0;
28789 int arg1 = (int) 0 ;
28790 int arg2 = (int) 0 ;
28791 int arg3 = (int) 0 ;
28792 wxAcceleratorEntry *result = 0 ;
28793 int val1 ;
28794 int ecode1 = 0 ;
28795 int val2 ;
28796 int ecode2 = 0 ;
28797 int val3 ;
28798 int ecode3 = 0 ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 PyObject * obj2 = 0 ;
28802 char * kwnames[] = {
28803 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28804 };
28805
28806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28807 if (obj0) {
28808 ecode1 = SWIG_AsVal_int(obj0, &val1);
28809 if (!SWIG_IsOK(ecode1)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28811 }
28812 arg1 = static_cast< int >(val1);
28813 }
28814 if (obj1) {
28815 ecode2 = SWIG_AsVal_int(obj1, &val2);
28816 if (!SWIG_IsOK(ecode2)) {
28817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28818 }
28819 arg2 = static_cast< int >(val2);
28820 }
28821 if (obj2) {
28822 ecode3 = SWIG_AsVal_int(obj2, &val3);
28823 if (!SWIG_IsOK(ecode3)) {
28824 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28825 }
28826 arg3 = static_cast< int >(val3);
28827 }
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28842 PyObject *resultobj = 0;
28843 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28844 void *argp1 = 0 ;
28845 int res1 = 0 ;
28846 PyObject *swig_obj[1] ;
28847
28848 if (!args) SWIG_fail;
28849 swig_obj[0] = args;
28850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28851 if (!SWIG_IsOK(res1)) {
28852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28853 }
28854 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28855 {
28856 PyThreadState* __tstate = wxPyBeginAllowThreads();
28857 delete arg1;
28858
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_Py_Void();
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28870 PyObject *resultobj = 0;
28871 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28872 int arg2 ;
28873 int arg3 ;
28874 int arg4 ;
28875 void *argp1 = 0 ;
28876 int res1 = 0 ;
28877 int val2 ;
28878 int ecode2 = 0 ;
28879 int val3 ;
28880 int ecode3 = 0 ;
28881 int val4 ;
28882 int ecode4 = 0 ;
28883 PyObject * obj0 = 0 ;
28884 PyObject * obj1 = 0 ;
28885 PyObject * obj2 = 0 ;
28886 PyObject * obj3 = 0 ;
28887 char * kwnames[] = {
28888 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28889 };
28890
28891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28893 if (!SWIG_IsOK(res1)) {
28894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28895 }
28896 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28897 ecode2 = SWIG_AsVal_int(obj1, &val2);
28898 if (!SWIG_IsOK(ecode2)) {
28899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28900 }
28901 arg2 = static_cast< int >(val2);
28902 ecode3 = SWIG_AsVal_int(obj2, &val3);
28903 if (!SWIG_IsOK(ecode3)) {
28904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28905 }
28906 arg3 = static_cast< int >(val3);
28907 ecode4 = SWIG_AsVal_int(obj3, &val4);
28908 if (!SWIG_IsOK(ecode4)) {
28909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28910 }
28911 arg4 = static_cast< int >(val4);
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 (arg1)->Set(arg2,arg3,arg4);
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 resultobj = SWIG_Py_Void();
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 PyObject *resultobj = 0;
28927 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28928 int result;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 PyObject *swig_obj[1] ;
28932
28933 if (!args) SWIG_fail;
28934 swig_obj[0] = args;
28935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28936 if (!SWIG_IsOK(res1)) {
28937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28938 }
28939 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 result = (int)(arg1)->GetFlags();
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 resultobj = SWIG_From_int(static_cast< int >(result));
28947 return resultobj;
28948 fail:
28949 return NULL;
28950 }
28951
28952
28953 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28954 PyObject *resultobj = 0;
28955 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28956 int result;
28957 void *argp1 = 0 ;
28958 int res1 = 0 ;
28959 PyObject *swig_obj[1] ;
28960
28961 if (!args) SWIG_fail;
28962 swig_obj[0] = args;
28963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28964 if (!SWIG_IsOK(res1)) {
28965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28966 }
28967 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (int)(arg1)->GetKeyCode();
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 resultobj = SWIG_From_int(static_cast< int >(result));
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28982 PyObject *resultobj = 0;
28983 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28984 int result;
28985 void *argp1 = 0 ;
28986 int res1 = 0 ;
28987 PyObject *swig_obj[1] ;
28988
28989 if (!args) SWIG_fail;
28990 swig_obj[0] = args;
28991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28992 if (!SWIG_IsOK(res1)) {
28993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28994 }
28995 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28996 {
28997 PyThreadState* __tstate = wxPyBeginAllowThreads();
28998 result = (int)(arg1)->GetCommand();
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 resultobj = SWIG_From_int(static_cast< int >(result));
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29010 PyObject *obj;
29011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29012 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29013 return SWIG_Py_Void();
29014 }
29015
29016 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29017 return SWIG_Python_InitShadowInstance(args);
29018 }
29019
29020 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj = 0;
29022 int arg1 ;
29023 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29024 wxAcceleratorTable *result = 0 ;
29025 PyObject * obj0 = 0 ;
29026 char * kwnames[] = {
29027 (char *) "n", NULL
29028 };
29029
29030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29031 {
29032 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29033 if (arg2) arg1 = PyList_Size(obj0);
29034 else arg1 = 0;
29035 }
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29043 return resultobj;
29044 fail:
29045 return NULL;
29046 }
29047
29048
29049 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 PyObject *resultobj = 0;
29051 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29052 void *argp1 = 0 ;
29053 int res1 = 0 ;
29054 PyObject *swig_obj[1] ;
29055
29056 if (!args) SWIG_fail;
29057 swig_obj[0] = args;
29058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29059 if (!SWIG_IsOK(res1)) {
29060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29061 }
29062 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 delete arg1;
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_Py_Void();
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29078 PyObject *resultobj = 0;
29079 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29080 bool result;
29081 void *argp1 = 0 ;
29082 int res1 = 0 ;
29083 PyObject *swig_obj[1] ;
29084
29085 if (!args) SWIG_fail;
29086 swig_obj[0] = args;
29087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29088 if (!SWIG_IsOK(res1)) {
29089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29090 }
29091 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29092 {
29093 PyThreadState* __tstate = wxPyBeginAllowThreads();
29094 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 {
29099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29100 }
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *obj;
29109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29110 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29111 return SWIG_Py_Void();
29112 }
29113
29114 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29115 return SWIG_Python_InitShadowInstance(args);
29116 }
29117
29118 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29119 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29120 return 1;
29121 }
29122
29123
29124 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29125 PyObject *pyobj = 0;
29126
29127 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29128 return pyobj;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj = 0;
29134 wxString *arg1 = 0 ;
29135 wxAcceleratorEntry *result = 0 ;
29136 bool temp1 = false ;
29137 PyObject * obj0 = 0 ;
29138 char * kwnames[] = {
29139 (char *) "label", NULL
29140 };
29141
29142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29143 {
29144 arg1 = wxString_in_helper(obj0);
29145 if (arg1 == NULL) SWIG_fail;
29146 temp1 = true;
29147 }
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29155 {
29156 if (temp1)
29157 delete arg1;
29158 }
29159 return resultobj;
29160 fail:
29161 {
29162 if (temp1)
29163 delete arg1;
29164 }
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN int PanelNameStr_set(PyObject *) {
29170 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29171 return 1;
29172 }
29173
29174
29175 SWIGINTERN PyObject *PanelNameStr_get(void) {
29176 PyObject *pyobj = 0;
29177
29178 {
29179 #if wxUSE_UNICODE
29180 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29181 #else
29182 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29183 #endif
29184 }
29185 return pyobj;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29190 PyObject *resultobj = 0;
29191 wxVisualAttributes *result = 0 ;
29192
29193 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29194 {
29195 PyThreadState* __tstate = wxPyBeginAllowThreads();
29196 result = (wxVisualAttributes *)new_wxVisualAttributes();
29197 wxPyEndAllowThreads(__tstate);
29198 if (PyErr_Occurred()) SWIG_fail;
29199 }
29200 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29201 return resultobj;
29202 fail:
29203 return NULL;
29204 }
29205
29206
29207 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29208 PyObject *resultobj = 0;
29209 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29210 void *argp1 = 0 ;
29211 int res1 = 0 ;
29212 PyObject *swig_obj[1] ;
29213
29214 if (!args) SWIG_fail;
29215 swig_obj[0] = args;
29216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29217 if (!SWIG_IsOK(res1)) {
29218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29219 }
29220 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29221 {
29222 PyThreadState* __tstate = wxPyBeginAllowThreads();
29223 delete_wxVisualAttributes(arg1);
29224
29225 wxPyEndAllowThreads(__tstate);
29226 if (PyErr_Occurred()) SWIG_fail;
29227 }
29228 resultobj = SWIG_Py_Void();
29229 return resultobj;
29230 fail:
29231 return NULL;
29232 }
29233
29234
29235 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29236 PyObject *resultobj = 0;
29237 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29238 wxFont *arg2 = (wxFont *) 0 ;
29239 void *argp1 = 0 ;
29240 int res1 = 0 ;
29241 void *argp2 = 0 ;
29242 int res2 = 0 ;
29243 PyObject *swig_obj[2] ;
29244
29245 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29247 if (!SWIG_IsOK(res1)) {
29248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29249 }
29250 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29251 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29252 if (!SWIG_IsOK(res2)) {
29253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29254 }
29255 arg2 = reinterpret_cast< wxFont * >(argp2);
29256 if (arg1) (arg1)->font = *arg2;
29257
29258 resultobj = SWIG_Py_Void();
29259 return resultobj;
29260 fail:
29261 return NULL;
29262 }
29263
29264
29265 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29266 PyObject *resultobj = 0;
29267 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29268 wxFont *result = 0 ;
29269 void *argp1 = 0 ;
29270 int res1 = 0 ;
29271 PyObject *swig_obj[1] ;
29272
29273 if (!args) SWIG_fail;
29274 swig_obj[0] = args;
29275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29278 }
29279 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29280 result = (wxFont *)& ((arg1)->font);
29281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29282 return resultobj;
29283 fail:
29284 return NULL;
29285 }
29286
29287
29288 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29289 PyObject *resultobj = 0;
29290 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29291 wxColour *arg2 = (wxColour *) 0 ;
29292 void *argp1 = 0 ;
29293 int res1 = 0 ;
29294 void *argp2 = 0 ;
29295 int res2 = 0 ;
29296 PyObject *swig_obj[2] ;
29297
29298 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29300 if (!SWIG_IsOK(res1)) {
29301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29302 }
29303 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29304 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29305 if (!SWIG_IsOK(res2)) {
29306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29307 }
29308 arg2 = reinterpret_cast< wxColour * >(argp2);
29309 if (arg1) (arg1)->colFg = *arg2;
29310
29311 resultobj = SWIG_Py_Void();
29312 return resultobj;
29313 fail:
29314 return NULL;
29315 }
29316
29317
29318 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29319 PyObject *resultobj = 0;
29320 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29321 wxColour *result = 0 ;
29322 void *argp1 = 0 ;
29323 int res1 = 0 ;
29324 PyObject *swig_obj[1] ;
29325
29326 if (!args) SWIG_fail;
29327 swig_obj[0] = args;
29328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29329 if (!SWIG_IsOK(res1)) {
29330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29331 }
29332 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29333 result = (wxColour *)& ((arg1)->colFg);
29334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29335 return resultobj;
29336 fail:
29337 return NULL;
29338 }
29339
29340
29341 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *resultobj = 0;
29343 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29344 wxColour *arg2 = (wxColour *) 0 ;
29345 void *argp1 = 0 ;
29346 int res1 = 0 ;
29347 void *argp2 = 0 ;
29348 int res2 = 0 ;
29349 PyObject *swig_obj[2] ;
29350
29351 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29353 if (!SWIG_IsOK(res1)) {
29354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29355 }
29356 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29357 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29358 if (!SWIG_IsOK(res2)) {
29359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29360 }
29361 arg2 = reinterpret_cast< wxColour * >(argp2);
29362 if (arg1) (arg1)->colBg = *arg2;
29363
29364 resultobj = SWIG_Py_Void();
29365 return resultobj;
29366 fail:
29367 return NULL;
29368 }
29369
29370
29371 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29372 PyObject *resultobj = 0;
29373 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29374 wxColour *result = 0 ;
29375 void *argp1 = 0 ;
29376 int res1 = 0 ;
29377 PyObject *swig_obj[1] ;
29378
29379 if (!args) SWIG_fail;
29380 swig_obj[0] = args;
29381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29382 if (!SWIG_IsOK(res1)) {
29383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29384 }
29385 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29386 result = (wxColour *)& ((arg1)->colBg);
29387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29395 PyObject *obj;
29396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29397 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29398 return SWIG_Py_Void();
29399 }
29400
29401 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29402 return SWIG_Python_InitShadowInstance(args);
29403 }
29404
29405 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29406 PyObject *resultobj = 0;
29407 wxWindow *arg1 = (wxWindow *) 0 ;
29408 int arg2 = (int) (int)-1 ;
29409 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29410 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29411 wxSize const &arg4_defvalue = wxDefaultSize ;
29412 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29413 long arg5 = (long) 0 ;
29414 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29415 wxString *arg6 = (wxString *) &arg6_defvalue ;
29416 wxWindow *result = 0 ;
29417 void *argp1 = 0 ;
29418 int res1 = 0 ;
29419 int val2 ;
29420 int ecode2 = 0 ;
29421 wxPoint temp3 ;
29422 wxSize temp4 ;
29423 long val5 ;
29424 int ecode5 = 0 ;
29425 bool temp6 = false ;
29426 PyObject * obj0 = 0 ;
29427 PyObject * obj1 = 0 ;
29428 PyObject * obj2 = 0 ;
29429 PyObject * obj3 = 0 ;
29430 PyObject * obj4 = 0 ;
29431 PyObject * obj5 = 0 ;
29432 char * kwnames[] = {
29433 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29434 };
29435
29436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29438 if (!SWIG_IsOK(res1)) {
29439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29440 }
29441 arg1 = reinterpret_cast< wxWindow * >(argp1);
29442 if (obj1) {
29443 ecode2 = SWIG_AsVal_int(obj1, &val2);
29444 if (!SWIG_IsOK(ecode2)) {
29445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29446 }
29447 arg2 = static_cast< int >(val2);
29448 }
29449 if (obj2) {
29450 {
29451 arg3 = &temp3;
29452 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29453 }
29454 }
29455 if (obj3) {
29456 {
29457 arg4 = &temp4;
29458 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29459 }
29460 }
29461 if (obj4) {
29462 ecode5 = SWIG_AsVal_long(obj4, &val5);
29463 if (!SWIG_IsOK(ecode5)) {
29464 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29465 }
29466 arg5 = static_cast< long >(val5);
29467 }
29468 if (obj5) {
29469 {
29470 arg6 = wxString_in_helper(obj5);
29471 if (arg6 == NULL) SWIG_fail;
29472 temp6 = true;
29473 }
29474 }
29475 {
29476 if (!wxPyCheckForApp()) SWIG_fail;
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29483 {
29484 if (temp6)
29485 delete arg6;
29486 }
29487 return resultobj;
29488 fail:
29489 {
29490 if (temp6)
29491 delete arg6;
29492 }
29493 return NULL;
29494 }
29495
29496
29497 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29498 PyObject *resultobj = 0;
29499 wxWindow *result = 0 ;
29500
29501 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29502 {
29503 if (!wxPyCheckForApp()) SWIG_fail;
29504 PyThreadState* __tstate = wxPyBeginAllowThreads();
29505 result = (wxWindow *)new wxWindow();
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = 0;
29518 wxWindow *arg1 = (wxWindow *) 0 ;
29519 wxWindow *arg2 = (wxWindow *) 0 ;
29520 int arg3 = (int) (int)-1 ;
29521 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29522 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29523 wxSize const &arg5_defvalue = wxDefaultSize ;
29524 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29525 long arg6 = (long) 0 ;
29526 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29527 wxString *arg7 = (wxString *) &arg7_defvalue ;
29528 bool result;
29529 void *argp1 = 0 ;
29530 int res1 = 0 ;
29531 void *argp2 = 0 ;
29532 int res2 = 0 ;
29533 int val3 ;
29534 int ecode3 = 0 ;
29535 wxPoint temp4 ;
29536 wxSize temp5 ;
29537 long val6 ;
29538 int ecode6 = 0 ;
29539 bool temp7 = false ;
29540 PyObject * obj0 = 0 ;
29541 PyObject * obj1 = 0 ;
29542 PyObject * obj2 = 0 ;
29543 PyObject * obj3 = 0 ;
29544 PyObject * obj4 = 0 ;
29545 PyObject * obj5 = 0 ;
29546 PyObject * obj6 = 0 ;
29547 char * kwnames[] = {
29548 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29549 };
29550
29551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29555 }
29556 arg1 = reinterpret_cast< wxWindow * >(argp1);
29557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29558 if (!SWIG_IsOK(res2)) {
29559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29560 }
29561 arg2 = reinterpret_cast< wxWindow * >(argp2);
29562 if (obj2) {
29563 ecode3 = SWIG_AsVal_int(obj2, &val3);
29564 if (!SWIG_IsOK(ecode3)) {
29565 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29566 }
29567 arg3 = static_cast< int >(val3);
29568 }
29569 if (obj3) {
29570 {
29571 arg4 = &temp4;
29572 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29573 }
29574 }
29575 if (obj4) {
29576 {
29577 arg5 = &temp5;
29578 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29579 }
29580 }
29581 if (obj5) {
29582 ecode6 = SWIG_AsVal_long(obj5, &val6);
29583 if (!SWIG_IsOK(ecode6)) {
29584 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29585 }
29586 arg6 = static_cast< long >(val6);
29587 }
29588 if (obj6) {
29589 {
29590 arg7 = wxString_in_helper(obj6);
29591 if (arg7 == NULL) SWIG_fail;
29592 temp7 = true;
29593 }
29594 }
29595 {
29596 PyThreadState* __tstate = wxPyBeginAllowThreads();
29597 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29598 wxPyEndAllowThreads(__tstate);
29599 if (PyErr_Occurred()) SWIG_fail;
29600 }
29601 {
29602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29603 }
29604 {
29605 if (temp7)
29606 delete arg7;
29607 }
29608 return resultobj;
29609 fail:
29610 {
29611 if (temp7)
29612 delete arg7;
29613 }
29614 return NULL;
29615 }
29616
29617
29618 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29619 PyObject *resultobj = 0;
29620 wxWindow *arg1 = (wxWindow *) 0 ;
29621 bool arg2 = (bool) false ;
29622 bool result;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 bool val2 ;
29626 int ecode2 = 0 ;
29627 PyObject * obj0 = 0 ;
29628 PyObject * obj1 = 0 ;
29629 char * kwnames[] = {
29630 (char *) "self",(char *) "force", NULL
29631 };
29632
29633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29635 if (!SWIG_IsOK(res1)) {
29636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29637 }
29638 arg1 = reinterpret_cast< wxWindow * >(argp1);
29639 if (obj1) {
29640 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29641 if (!SWIG_IsOK(ecode2)) {
29642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29643 }
29644 arg2 = static_cast< bool >(val2);
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (bool)(arg1)->Close(arg2);
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 {
29653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29654 }
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29662 PyObject *resultobj = 0;
29663 wxWindow *arg1 = (wxWindow *) 0 ;
29664 bool result;
29665 void *argp1 = 0 ;
29666 int res1 = 0 ;
29667 PyObject *swig_obj[1] ;
29668
29669 if (!args) SWIG_fail;
29670 swig_obj[0] = args;
29671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29672 if (!SWIG_IsOK(res1)) {
29673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29674 }
29675 arg1 = reinterpret_cast< wxWindow * >(argp1);
29676 {
29677 PyThreadState* __tstate = wxPyBeginAllowThreads();
29678 result = (bool)(arg1)->Destroy();
29679 wxPyEndAllowThreads(__tstate);
29680 if (PyErr_Occurred()) SWIG_fail;
29681 }
29682 {
29683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29684 }
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29692 PyObject *resultobj = 0;
29693 wxWindow *arg1 = (wxWindow *) 0 ;
29694 bool result;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 PyObject *swig_obj[1] ;
29698
29699 if (!args) SWIG_fail;
29700 swig_obj[0] = args;
29701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29704 }
29705 arg1 = reinterpret_cast< wxWindow * >(argp1);
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (bool)(arg1)->DestroyChildren();
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 {
29713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29714 }
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29722 PyObject *resultobj = 0;
29723 wxWindow *arg1 = (wxWindow *) 0 ;
29724 bool result;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 PyObject *swig_obj[1] ;
29728
29729 if (!args) SWIG_fail;
29730 swig_obj[0] = args;
29731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29732 if (!SWIG_IsOK(res1)) {
29733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29734 }
29735 arg1 = reinterpret_cast< wxWindow * >(argp1);
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29752 PyObject *resultobj = 0;
29753 wxWindow *arg1 = (wxWindow *) 0 ;
29754 wxString *arg2 = 0 ;
29755 void *argp1 = 0 ;
29756 int res1 = 0 ;
29757 bool temp2 = false ;
29758 PyObject * obj0 = 0 ;
29759 PyObject * obj1 = 0 ;
29760 char * kwnames[] = {
29761 (char *) "self",(char *) "label", NULL
29762 };
29763
29764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29766 if (!SWIG_IsOK(res1)) {
29767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29768 }
29769 arg1 = reinterpret_cast< wxWindow * >(argp1);
29770 {
29771 arg2 = wxString_in_helper(obj1);
29772 if (arg2 == NULL) SWIG_fail;
29773 temp2 = true;
29774 }
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 (arg1)->SetLabel((wxString const &)*arg2);
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_Py_Void();
29782 {
29783 if (temp2)
29784 delete arg2;
29785 }
29786 return resultobj;
29787 fail:
29788 {
29789 if (temp2)
29790 delete arg2;
29791 }
29792 return NULL;
29793 }
29794
29795
29796 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29797 PyObject *resultobj = 0;
29798 wxWindow *arg1 = (wxWindow *) 0 ;
29799 wxString result;
29800 void *argp1 = 0 ;
29801 int res1 = 0 ;
29802 PyObject *swig_obj[1] ;
29803
29804 if (!args) SWIG_fail;
29805 swig_obj[0] = args;
29806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29807 if (!SWIG_IsOK(res1)) {
29808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29809 }
29810 arg1 = reinterpret_cast< wxWindow * >(argp1);
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 result = ((wxWindow const *)arg1)->GetLabel();
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 {
29818 #if wxUSE_UNICODE
29819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29820 #else
29821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29822 #endif
29823 }
29824 return resultobj;
29825 fail:
29826 return NULL;
29827 }
29828
29829
29830 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29831 PyObject *resultobj = 0;
29832 wxWindow *arg1 = (wxWindow *) 0 ;
29833 wxString *arg2 = 0 ;
29834 void *argp1 = 0 ;
29835 int res1 = 0 ;
29836 bool temp2 = false ;
29837 PyObject * obj0 = 0 ;
29838 PyObject * obj1 = 0 ;
29839 char * kwnames[] = {
29840 (char *) "self",(char *) "name", NULL
29841 };
29842
29843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29845 if (!SWIG_IsOK(res1)) {
29846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29847 }
29848 arg1 = reinterpret_cast< wxWindow * >(argp1);
29849 {
29850 arg2 = wxString_in_helper(obj1);
29851 if (arg2 == NULL) SWIG_fail;
29852 temp2 = true;
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 (arg1)->SetName((wxString const &)*arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 resultobj = SWIG_Py_Void();
29861 {
29862 if (temp2)
29863 delete arg2;
29864 }
29865 return resultobj;
29866 fail:
29867 {
29868 if (temp2)
29869 delete arg2;
29870 }
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29876 PyObject *resultobj = 0;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 wxString result;
29879 void *argp1 = 0 ;
29880 int res1 = 0 ;
29881 PyObject *swig_obj[1] ;
29882
29883 if (!args) SWIG_fail;
29884 swig_obj[0] = args;
29885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29888 }
29889 arg1 = reinterpret_cast< wxWindow * >(argp1);
29890 {
29891 PyThreadState* __tstate = wxPyBeginAllowThreads();
29892 result = ((wxWindow const *)arg1)->GetName();
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 {
29897 #if wxUSE_UNICODE
29898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29899 #else
29900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29901 #endif
29902 }
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj = 0;
29911 wxWindow *arg1 = (wxWindow *) 0 ;
29912 wxWindowVariant arg2 ;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 int val2 ;
29916 int ecode2 = 0 ;
29917 PyObject * obj0 = 0 ;
29918 PyObject * obj1 = 0 ;
29919 char * kwnames[] = {
29920 (char *) "self",(char *) "variant", NULL
29921 };
29922
29923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29925 if (!SWIG_IsOK(res1)) {
29926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29927 }
29928 arg1 = reinterpret_cast< wxWindow * >(argp1);
29929 ecode2 = SWIG_AsVal_int(obj1, &val2);
29930 if (!SWIG_IsOK(ecode2)) {
29931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29932 }
29933 arg2 = static_cast< wxWindowVariant >(val2);
29934 {
29935 PyThreadState* __tstate = wxPyBeginAllowThreads();
29936 (arg1)->SetWindowVariant(arg2);
29937 wxPyEndAllowThreads(__tstate);
29938 if (PyErr_Occurred()) SWIG_fail;
29939 }
29940 resultobj = SWIG_Py_Void();
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29948 PyObject *resultobj = 0;
29949 wxWindow *arg1 = (wxWindow *) 0 ;
29950 wxWindowVariant result;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 PyObject *swig_obj[1] ;
29954
29955 if (!args) SWIG_fail;
29956 swig_obj[0] = args;
29957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29960 }
29961 arg1 = reinterpret_cast< wxWindow * >(argp1);
29962 {
29963 PyThreadState* __tstate = wxPyBeginAllowThreads();
29964 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29965 wxPyEndAllowThreads(__tstate);
29966 if (PyErr_Occurred()) SWIG_fail;
29967 }
29968 resultobj = SWIG_From_int(static_cast< int >(result));
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj = 0;
29977 wxWindow *arg1 = (wxWindow *) 0 ;
29978 int arg2 ;
29979 void *argp1 = 0 ;
29980 int res1 = 0 ;
29981 int val2 ;
29982 int ecode2 = 0 ;
29983 PyObject * obj0 = 0 ;
29984 PyObject * obj1 = 0 ;
29985 char * kwnames[] = {
29986 (char *) "self",(char *) "winid", NULL
29987 };
29988
29989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29991 if (!SWIG_IsOK(res1)) {
29992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29993 }
29994 arg1 = reinterpret_cast< wxWindow * >(argp1);
29995 ecode2 = SWIG_AsVal_int(obj1, &val2);
29996 if (!SWIG_IsOK(ecode2)) {
29997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29998 }
29999 arg2 = static_cast< int >(val2);
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 (arg1)->SetId(arg2);
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 resultobj = SWIG_Py_Void();
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30014 PyObject *resultobj = 0;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 int result;
30017 void *argp1 = 0 ;
30018 int res1 = 0 ;
30019 PyObject *swig_obj[1] ;
30020
30021 if (!args) SWIG_fail;
30022 swig_obj[0] = args;
30023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30024 if (!SWIG_IsOK(res1)) {
30025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30026 }
30027 arg1 = reinterpret_cast< wxWindow * >(argp1);
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (int)((wxWindow const *)arg1)->GetId();
30031 wxPyEndAllowThreads(__tstate);
30032 if (PyErr_Occurred()) SWIG_fail;
30033 }
30034 resultobj = SWIG_From_int(static_cast< int >(result));
30035 return resultobj;
30036 fail:
30037 return NULL;
30038 }
30039
30040
30041 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30042 PyObject *resultobj = 0;
30043 int result;
30044
30045 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 result = (int)wxWindow::NewControlId();
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 resultobj = SWIG_From_int(static_cast< int >(result));
30053 return resultobj;
30054 fail:
30055 return NULL;
30056 }
30057
30058
30059 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30060 PyObject *resultobj = 0;
30061 int arg1 ;
30062 int result;
30063 int val1 ;
30064 int ecode1 = 0 ;
30065 PyObject * obj0 = 0 ;
30066 char * kwnames[] = {
30067 (char *) "winid", NULL
30068 };
30069
30070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30071 ecode1 = SWIG_AsVal_int(obj0, &val1);
30072 if (!SWIG_IsOK(ecode1)) {
30073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30074 }
30075 arg1 = static_cast< int >(val1);
30076 {
30077 PyThreadState* __tstate = wxPyBeginAllowThreads();
30078 result = (int)wxWindow::NextControlId(arg1);
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 resultobj = SWIG_From_int(static_cast< int >(result));
30083 return resultobj;
30084 fail:
30085 return NULL;
30086 }
30087
30088
30089 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30090 PyObject *resultobj = 0;
30091 int arg1 ;
30092 int result;
30093 int val1 ;
30094 int ecode1 = 0 ;
30095 PyObject * obj0 = 0 ;
30096 char * kwnames[] = {
30097 (char *) "winid", NULL
30098 };
30099
30100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30101 ecode1 = SWIG_AsVal_int(obj0, &val1);
30102 if (!SWIG_IsOK(ecode1)) {
30103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30104 }
30105 arg1 = static_cast< int >(val1);
30106 {
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (int)wxWindow::PrevControlId(arg1);
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_From_int(static_cast< int >(result));
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = 0;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 wxSize *arg2 = 0 ;
30123 void *argp1 = 0 ;
30124 int res1 = 0 ;
30125 wxSize temp2 ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 char * kwnames[] = {
30129 (char *) "self",(char *) "size", NULL
30130 };
30131
30132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30134 if (!SWIG_IsOK(res1)) {
30135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30136 }
30137 arg1 = reinterpret_cast< wxWindow * >(argp1);
30138 {
30139 arg2 = &temp2;
30140 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30141 }
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetSize((wxSize const &)*arg2);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj = 0;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 int arg2 ;
30159 int arg3 ;
30160 int arg4 ;
30161 int arg5 ;
30162 int arg6 = (int) wxSIZE_AUTO ;
30163 void *argp1 = 0 ;
30164 int res1 = 0 ;
30165 int val2 ;
30166 int ecode2 = 0 ;
30167 int val3 ;
30168 int ecode3 = 0 ;
30169 int val4 ;
30170 int ecode4 = 0 ;
30171 int val5 ;
30172 int ecode5 = 0 ;
30173 int val6 ;
30174 int ecode6 = 0 ;
30175 PyObject * obj0 = 0 ;
30176 PyObject * obj1 = 0 ;
30177 PyObject * obj2 = 0 ;
30178 PyObject * obj3 = 0 ;
30179 PyObject * obj4 = 0 ;
30180 PyObject * obj5 = 0 ;
30181 char * kwnames[] = {
30182 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30183 };
30184
30185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30187 if (!SWIG_IsOK(res1)) {
30188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30189 }
30190 arg1 = reinterpret_cast< wxWindow * >(argp1);
30191 ecode2 = SWIG_AsVal_int(obj1, &val2);
30192 if (!SWIG_IsOK(ecode2)) {
30193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30194 }
30195 arg2 = static_cast< int >(val2);
30196 ecode3 = SWIG_AsVal_int(obj2, &val3);
30197 if (!SWIG_IsOK(ecode3)) {
30198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30199 }
30200 arg3 = static_cast< int >(val3);
30201 ecode4 = SWIG_AsVal_int(obj3, &val4);
30202 if (!SWIG_IsOK(ecode4)) {
30203 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30204 }
30205 arg4 = static_cast< int >(val4);
30206 ecode5 = SWIG_AsVal_int(obj4, &val5);
30207 if (!SWIG_IsOK(ecode5)) {
30208 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30209 }
30210 arg5 = static_cast< int >(val5);
30211 if (obj5) {
30212 ecode6 = SWIG_AsVal_int(obj5, &val6);
30213 if (!SWIG_IsOK(ecode6)) {
30214 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30215 }
30216 arg6 = static_cast< int >(val6);
30217 }
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 resultobj = SWIG_Py_Void();
30225 return resultobj;
30226 fail:
30227 return NULL;
30228 }
30229
30230
30231 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30232 PyObject *resultobj = 0;
30233 wxWindow *arg1 = (wxWindow *) 0 ;
30234 wxRect *arg2 = 0 ;
30235 int arg3 = (int) wxSIZE_AUTO ;
30236 void *argp1 = 0 ;
30237 int res1 = 0 ;
30238 wxRect temp2 ;
30239 int val3 ;
30240 int ecode3 = 0 ;
30241 PyObject * obj0 = 0 ;
30242 PyObject * obj1 = 0 ;
30243 PyObject * obj2 = 0 ;
30244 char * kwnames[] = {
30245 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30246 };
30247
30248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30252 }
30253 arg1 = reinterpret_cast< wxWindow * >(argp1);
30254 {
30255 arg2 = &temp2;
30256 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30257 }
30258 if (obj2) {
30259 ecode3 = SWIG_AsVal_int(obj2, &val3);
30260 if (!SWIG_IsOK(ecode3)) {
30261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30262 }
30263 arg3 = static_cast< int >(val3);
30264 }
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 resultobj = SWIG_Py_Void();
30272 return resultobj;
30273 fail:
30274 return NULL;
30275 }
30276
30277
30278 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30279 PyObject *resultobj = 0;
30280 wxWindow *arg1 = (wxWindow *) 0 ;
30281 int arg2 ;
30282 int arg3 ;
30283 void *argp1 = 0 ;
30284 int res1 = 0 ;
30285 int val2 ;
30286 int ecode2 = 0 ;
30287 int val3 ;
30288 int ecode3 = 0 ;
30289 PyObject * obj0 = 0 ;
30290 PyObject * obj1 = 0 ;
30291 PyObject * obj2 = 0 ;
30292 char * kwnames[] = {
30293 (char *) "self",(char *) "width",(char *) "height", NULL
30294 };
30295
30296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30298 if (!SWIG_IsOK(res1)) {
30299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30300 }
30301 arg1 = reinterpret_cast< wxWindow * >(argp1);
30302 ecode2 = SWIG_AsVal_int(obj1, &val2);
30303 if (!SWIG_IsOK(ecode2)) {
30304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30305 }
30306 arg2 = static_cast< int >(val2);
30307 ecode3 = SWIG_AsVal_int(obj2, &val3);
30308 if (!SWIG_IsOK(ecode3)) {
30309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30310 }
30311 arg3 = static_cast< int >(val3);
30312 {
30313 PyThreadState* __tstate = wxPyBeginAllowThreads();
30314 (arg1)->SetSize(arg2,arg3);
30315 wxPyEndAllowThreads(__tstate);
30316 if (PyErr_Occurred()) SWIG_fail;
30317 }
30318 resultobj = SWIG_Py_Void();
30319 return resultobj;
30320 fail:
30321 return NULL;
30322 }
30323
30324
30325 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30326 PyObject *resultobj = 0;
30327 wxWindow *arg1 = (wxWindow *) 0 ;
30328 wxPoint *arg2 = 0 ;
30329 int arg3 = (int) wxSIZE_USE_EXISTING ;
30330 void *argp1 = 0 ;
30331 int res1 = 0 ;
30332 wxPoint temp2 ;
30333 int val3 ;
30334 int ecode3 = 0 ;
30335 PyObject * obj0 = 0 ;
30336 PyObject * obj1 = 0 ;
30337 PyObject * obj2 = 0 ;
30338 char * kwnames[] = {
30339 (char *) "self",(char *) "pt",(char *) "flags", NULL
30340 };
30341
30342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30344 if (!SWIG_IsOK(res1)) {
30345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30346 }
30347 arg1 = reinterpret_cast< wxWindow * >(argp1);
30348 {
30349 arg2 = &temp2;
30350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30351 }
30352 if (obj2) {
30353 ecode3 = SWIG_AsVal_int(obj2, &val3);
30354 if (!SWIG_IsOK(ecode3)) {
30355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30356 }
30357 arg3 = static_cast< int >(val3);
30358 }
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 (arg1)->Move((wxPoint const &)*arg2,arg3);
30362 wxPyEndAllowThreads(__tstate);
30363 if (PyErr_Occurred()) SWIG_fail;
30364 }
30365 resultobj = SWIG_Py_Void();
30366 return resultobj;
30367 fail:
30368 return NULL;
30369 }
30370
30371
30372 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30373 PyObject *resultobj = 0;
30374 wxWindow *arg1 = (wxWindow *) 0 ;
30375 int arg2 ;
30376 int arg3 ;
30377 int arg4 = (int) wxSIZE_USE_EXISTING ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 int val2 ;
30381 int ecode2 = 0 ;
30382 int val3 ;
30383 int ecode3 = 0 ;
30384 int val4 ;
30385 int ecode4 = 0 ;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 PyObject * obj2 = 0 ;
30389 PyObject * obj3 = 0 ;
30390 char * kwnames[] = {
30391 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30392 };
30393
30394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30396 if (!SWIG_IsOK(res1)) {
30397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30398 }
30399 arg1 = reinterpret_cast< wxWindow * >(argp1);
30400 ecode2 = SWIG_AsVal_int(obj1, &val2);
30401 if (!SWIG_IsOK(ecode2)) {
30402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30403 }
30404 arg2 = static_cast< int >(val2);
30405 ecode3 = SWIG_AsVal_int(obj2, &val3);
30406 if (!SWIG_IsOK(ecode3)) {
30407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30408 }
30409 arg3 = static_cast< int >(val3);
30410 if (obj3) {
30411 ecode4 = SWIG_AsVal_int(obj3, &val4);
30412 if (!SWIG_IsOK(ecode4)) {
30413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30414 }
30415 arg4 = static_cast< int >(val4);
30416 }
30417 {
30418 PyThreadState* __tstate = wxPyBeginAllowThreads();
30419 (arg1)->Move(arg2,arg3,arg4);
30420 wxPyEndAllowThreads(__tstate);
30421 if (PyErr_Occurred()) SWIG_fail;
30422 }
30423 resultobj = SWIG_Py_Void();
30424 return resultobj;
30425 fail:
30426 return NULL;
30427 }
30428
30429
30430 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30431 PyObject *resultobj = 0;
30432 wxWindow *arg1 = (wxWindow *) 0 ;
30433 wxSize const &arg2_defvalue = wxDefaultSize ;
30434 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30435 void *argp1 = 0 ;
30436 int res1 = 0 ;
30437 wxSize temp2 ;
30438 PyObject * obj0 = 0 ;
30439 PyObject * obj1 = 0 ;
30440 char * kwnames[] = {
30441 (char *) "self",(char *) "size", NULL
30442 };
30443
30444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30448 }
30449 arg1 = reinterpret_cast< wxWindow * >(argp1);
30450 if (obj1) {
30451 {
30452 arg2 = &temp2;
30453 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30454 }
30455 }
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_Py_Void();
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30470 PyObject *resultobj = 0;
30471 wxWindow *arg1 = (wxWindow *) 0 ;
30472 void *argp1 = 0 ;
30473 int res1 = 0 ;
30474 PyObject *swig_obj[1] ;
30475
30476 if (!args) SWIG_fail;
30477 swig_obj[0] = args;
30478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30479 if (!SWIG_IsOK(res1)) {
30480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30481 }
30482 arg1 = reinterpret_cast< wxWindow * >(argp1);
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 (arg1)->Raise();
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 resultobj = SWIG_Py_Void();
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30497 PyObject *resultobj = 0;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 PyObject *swig_obj[1] ;
30502
30503 if (!args) SWIG_fail;
30504 swig_obj[0] = args;
30505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30508 }
30509 arg1 = reinterpret_cast< wxWindow * >(argp1);
30510 {
30511 PyThreadState* __tstate = wxPyBeginAllowThreads();
30512 (arg1)->Lower();
30513 wxPyEndAllowThreads(__tstate);
30514 if (PyErr_Occurred()) SWIG_fail;
30515 }
30516 resultobj = SWIG_Py_Void();
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30524 PyObject *resultobj = 0;
30525 wxWindow *arg1 = (wxWindow *) 0 ;
30526 wxSize *arg2 = 0 ;
30527 void *argp1 = 0 ;
30528 int res1 = 0 ;
30529 wxSize temp2 ;
30530 PyObject * obj0 = 0 ;
30531 PyObject * obj1 = 0 ;
30532 char * kwnames[] = {
30533 (char *) "self",(char *) "size", NULL
30534 };
30535
30536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30538 if (!SWIG_IsOK(res1)) {
30539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30540 }
30541 arg1 = reinterpret_cast< wxWindow * >(argp1);
30542 {
30543 arg2 = &temp2;
30544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30545 }
30546 {
30547 PyThreadState* __tstate = wxPyBeginAllowThreads();
30548 (arg1)->SetClientSize((wxSize const &)*arg2);
30549 wxPyEndAllowThreads(__tstate);
30550 if (PyErr_Occurred()) SWIG_fail;
30551 }
30552 resultobj = SWIG_Py_Void();
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30560 PyObject *resultobj = 0;
30561 wxWindow *arg1 = (wxWindow *) 0 ;
30562 int arg2 ;
30563 int arg3 ;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 int val2 ;
30567 int ecode2 = 0 ;
30568 int val3 ;
30569 int ecode3 = 0 ;
30570 PyObject * obj0 = 0 ;
30571 PyObject * obj1 = 0 ;
30572 PyObject * obj2 = 0 ;
30573 char * kwnames[] = {
30574 (char *) "self",(char *) "width",(char *) "height", NULL
30575 };
30576
30577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30581 }
30582 arg1 = reinterpret_cast< wxWindow * >(argp1);
30583 ecode2 = SWIG_AsVal_int(obj1, &val2);
30584 if (!SWIG_IsOK(ecode2)) {
30585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30586 }
30587 arg2 = static_cast< int >(val2);
30588 ecode3 = SWIG_AsVal_int(obj2, &val3);
30589 if (!SWIG_IsOK(ecode3)) {
30590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30591 }
30592 arg3 = static_cast< int >(val3);
30593 {
30594 PyThreadState* __tstate = wxPyBeginAllowThreads();
30595 (arg1)->SetClientSize(arg2,arg3);
30596 wxPyEndAllowThreads(__tstate);
30597 if (PyErr_Occurred()) SWIG_fail;
30598 }
30599 resultobj = SWIG_Py_Void();
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30607 PyObject *resultobj = 0;
30608 wxWindow *arg1 = (wxWindow *) 0 ;
30609 wxRect *arg2 = 0 ;
30610 void *argp1 = 0 ;
30611 int res1 = 0 ;
30612 wxRect temp2 ;
30613 PyObject * obj0 = 0 ;
30614 PyObject * obj1 = 0 ;
30615 char * kwnames[] = {
30616 (char *) "self",(char *) "rect", NULL
30617 };
30618
30619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30623 }
30624 arg1 = reinterpret_cast< wxWindow * >(argp1);
30625 {
30626 arg2 = &temp2;
30627 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30628 }
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 (arg1)->SetClientSize((wxRect const &)*arg2);
30632 wxPyEndAllowThreads(__tstate);
30633 if (PyErr_Occurred()) SWIG_fail;
30634 }
30635 resultobj = SWIG_Py_Void();
30636 return resultobj;
30637 fail:
30638 return NULL;
30639 }
30640
30641
30642 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30643 PyObject *resultobj = 0;
30644 wxWindow *arg1 = (wxWindow *) 0 ;
30645 wxPoint result;
30646 void *argp1 = 0 ;
30647 int res1 = 0 ;
30648 PyObject *swig_obj[1] ;
30649
30650 if (!args) SWIG_fail;
30651 swig_obj[0] = args;
30652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30653 if (!SWIG_IsOK(res1)) {
30654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30655 }
30656 arg1 = reinterpret_cast< wxWindow * >(argp1);
30657 {
30658 PyThreadState* __tstate = wxPyBeginAllowThreads();
30659 result = ((wxWindow const *)arg1)->GetPosition();
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 PyObject *resultobj = 0;
30672 wxWindow *arg1 = (wxWindow *) 0 ;
30673 int *arg2 = (int *) 0 ;
30674 int *arg3 = (int *) 0 ;
30675 void *argp1 = 0 ;
30676 int res1 = 0 ;
30677 int temp2 ;
30678 int res2 = SWIG_TMPOBJ ;
30679 int temp3 ;
30680 int res3 = SWIG_TMPOBJ ;
30681 PyObject *swig_obj[1] ;
30682
30683 arg2 = &temp2;
30684 arg3 = &temp3;
30685 if (!args) SWIG_fail;
30686 swig_obj[0] = args;
30687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30690 }
30691 arg1 = reinterpret_cast< wxWindow * >(argp1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_Py_Void();
30699 if (SWIG_IsTmpObj(res2)) {
30700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30701 } else {
30702 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30704 }
30705 if (SWIG_IsTmpObj(res3)) {
30706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30707 } else {
30708 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30710 }
30711 return resultobj;
30712 fail:
30713 return NULL;
30714 }
30715
30716
30717 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30718 PyObject *resultobj = 0;
30719 wxWindow *arg1 = (wxWindow *) 0 ;
30720 wxPoint result;
30721 void *argp1 = 0 ;
30722 int res1 = 0 ;
30723 PyObject *swig_obj[1] ;
30724
30725 if (!args) SWIG_fail;
30726 swig_obj[0] = args;
30727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30730 }
30731 arg1 = reinterpret_cast< wxWindow * >(argp1);
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = ((wxWindow const *)arg1)->GetScreenPosition();
30735 wxPyEndAllowThreads(__tstate);
30736 if (PyErr_Occurred()) SWIG_fail;
30737 }
30738 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30739 return resultobj;
30740 fail:
30741 return NULL;
30742 }
30743
30744
30745 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30746 PyObject *resultobj = 0;
30747 wxWindow *arg1 = (wxWindow *) 0 ;
30748 int *arg2 = (int *) 0 ;
30749 int *arg3 = (int *) 0 ;
30750 void *argp1 = 0 ;
30751 int res1 = 0 ;
30752 int temp2 ;
30753 int res2 = SWIG_TMPOBJ ;
30754 int temp3 ;
30755 int res3 = SWIG_TMPOBJ ;
30756 PyObject *swig_obj[1] ;
30757
30758 arg2 = &temp2;
30759 arg3 = &temp3;
30760 if (!args) SWIG_fail;
30761 swig_obj[0] = args;
30762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30763 if (!SWIG_IsOK(res1)) {
30764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30765 }
30766 arg1 = reinterpret_cast< wxWindow * >(argp1);
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30770 wxPyEndAllowThreads(__tstate);
30771 if (PyErr_Occurred()) SWIG_fail;
30772 }
30773 resultobj = SWIG_Py_Void();
30774 if (SWIG_IsTmpObj(res2)) {
30775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30776 } else {
30777 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30779 }
30780 if (SWIG_IsTmpObj(res3)) {
30781 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30782 } else {
30783 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30784 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30785 }
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30793 PyObject *resultobj = 0;
30794 wxWindow *arg1 = (wxWindow *) 0 ;
30795 wxRect result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 PyObject *swig_obj[1] ;
30799
30800 if (!args) SWIG_fail;
30801 swig_obj[0] = args;
30802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30805 }
30806 arg1 = reinterpret_cast< wxWindow * >(argp1);
30807 {
30808 PyThreadState* __tstate = wxPyBeginAllowThreads();
30809 result = ((wxWindow const *)arg1)->GetScreenRect();
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30814 return resultobj;
30815 fail:
30816 return NULL;
30817 }
30818
30819
30820 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30821 PyObject *resultobj = 0;
30822 wxWindow *arg1 = (wxWindow *) 0 ;
30823 wxSize result;
30824 void *argp1 = 0 ;
30825 int res1 = 0 ;
30826 PyObject *swig_obj[1] ;
30827
30828 if (!args) SWIG_fail;
30829 swig_obj[0] = args;
30830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30831 if (!SWIG_IsOK(res1)) {
30832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30833 }
30834 arg1 = reinterpret_cast< wxWindow * >(argp1);
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = ((wxWindow const *)arg1)->GetSize();
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 PyObject *resultobj = 0;
30850 wxWindow *arg1 = (wxWindow *) 0 ;
30851 int *arg2 = (int *) 0 ;
30852 int *arg3 = (int *) 0 ;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 int temp2 ;
30856 int res2 = SWIG_TMPOBJ ;
30857 int temp3 ;
30858 int res3 = SWIG_TMPOBJ ;
30859 PyObject *swig_obj[1] ;
30860
30861 arg2 = &temp2;
30862 arg3 = &temp3;
30863 if (!args) SWIG_fail;
30864 swig_obj[0] = args;
30865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30866 if (!SWIG_IsOK(res1)) {
30867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30868 }
30869 arg1 = reinterpret_cast< wxWindow * >(argp1);
30870 {
30871 PyThreadState* __tstate = wxPyBeginAllowThreads();
30872 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30873 wxPyEndAllowThreads(__tstate);
30874 if (PyErr_Occurred()) SWIG_fail;
30875 }
30876 resultobj = SWIG_Py_Void();
30877 if (SWIG_IsTmpObj(res2)) {
30878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30879 } else {
30880 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30882 }
30883 if (SWIG_IsTmpObj(res3)) {
30884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30885 } else {
30886 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30888 }
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30896 PyObject *resultobj = 0;
30897 wxWindow *arg1 = (wxWindow *) 0 ;
30898 wxRect result;
30899 void *argp1 = 0 ;
30900 int res1 = 0 ;
30901 PyObject *swig_obj[1] ;
30902
30903 if (!args) SWIG_fail;
30904 swig_obj[0] = args;
30905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30906 if (!SWIG_IsOK(res1)) {
30907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30908 }
30909 arg1 = reinterpret_cast< wxWindow * >(argp1);
30910 {
30911 PyThreadState* __tstate = wxPyBeginAllowThreads();
30912 result = ((wxWindow const *)arg1)->GetRect();
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30924 PyObject *resultobj = 0;
30925 wxWindow *arg1 = (wxWindow *) 0 ;
30926 wxSize result;
30927 void *argp1 = 0 ;
30928 int res1 = 0 ;
30929 PyObject *swig_obj[1] ;
30930
30931 if (!args) SWIG_fail;
30932 swig_obj[0] = args;
30933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30934 if (!SWIG_IsOK(res1)) {
30935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30936 }
30937 arg1 = reinterpret_cast< wxWindow * >(argp1);
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 result = ((wxWindow const *)arg1)->GetClientSize();
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30952 PyObject *resultobj = 0;
30953 wxWindow *arg1 = (wxWindow *) 0 ;
30954 int *arg2 = (int *) 0 ;
30955 int *arg3 = (int *) 0 ;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 int temp2 ;
30959 int res2 = SWIG_TMPOBJ ;
30960 int temp3 ;
30961 int res3 = SWIG_TMPOBJ ;
30962 PyObject *swig_obj[1] ;
30963
30964 arg2 = &temp2;
30965 arg3 = &temp3;
30966 if (!args) SWIG_fail;
30967 swig_obj[0] = args;
30968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30971 }
30972 arg1 = reinterpret_cast< wxWindow * >(argp1);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 if (SWIG_IsTmpObj(res2)) {
30981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30982 } else {
30983 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30985 }
30986 if (SWIG_IsTmpObj(res3)) {
30987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30988 } else {
30989 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30991 }
30992 return resultobj;
30993 fail:
30994 return NULL;
30995 }
30996
30997
30998 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30999 PyObject *resultobj = 0;
31000 wxWindow *arg1 = (wxWindow *) 0 ;
31001 wxPoint result;
31002 void *argp1 = 0 ;
31003 int res1 = 0 ;
31004 PyObject *swig_obj[1] ;
31005
31006 if (!args) SWIG_fail;
31007 swig_obj[0] = args;
31008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31009 if (!SWIG_IsOK(res1)) {
31010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31011 }
31012 arg1 = reinterpret_cast< wxWindow * >(argp1);
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31027 PyObject *resultobj = 0;
31028 wxWindow *arg1 = (wxWindow *) 0 ;
31029 wxRect result;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 PyObject *swig_obj[1] ;
31033
31034 if (!args) SWIG_fail;
31035 swig_obj[0] = args;
31036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31037 if (!SWIG_IsOK(res1)) {
31038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31039 }
31040 arg1 = reinterpret_cast< wxWindow * >(argp1);
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 result = ((wxWindow const *)arg1)->GetClientRect();
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31055 PyObject *resultobj = 0;
31056 wxWindow *arg1 = (wxWindow *) 0 ;
31057 wxSize result;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 PyObject *swig_obj[1] ;
31061
31062 if (!args) SWIG_fail;
31063 swig_obj[0] = args;
31064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31065 if (!SWIG_IsOK(res1)) {
31066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31067 }
31068 arg1 = reinterpret_cast< wxWindow * >(argp1);
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 result = ((wxWindow const *)arg1)->GetBestSize();
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31076 return resultobj;
31077 fail:
31078 return NULL;
31079 }
31080
31081
31082 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31083 PyObject *resultobj = 0;
31084 wxWindow *arg1 = (wxWindow *) 0 ;
31085 int *arg2 = (int *) 0 ;
31086 int *arg3 = (int *) 0 ;
31087 void *argp1 = 0 ;
31088 int res1 = 0 ;
31089 int temp2 ;
31090 int res2 = SWIG_TMPOBJ ;
31091 int temp3 ;
31092 int res3 = SWIG_TMPOBJ ;
31093 PyObject *swig_obj[1] ;
31094
31095 arg2 = &temp2;
31096 arg3 = &temp3;
31097 if (!args) SWIG_fail;
31098 swig_obj[0] = args;
31099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31102 }
31103 arg1 = reinterpret_cast< wxWindow * >(argp1);
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_Py_Void();
31111 if (SWIG_IsTmpObj(res2)) {
31112 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31113 } else {
31114 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31116 }
31117 if (SWIG_IsTmpObj(res3)) {
31118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31119 } else {
31120 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31122 }
31123 return resultobj;
31124 fail:
31125 return NULL;
31126 }
31127
31128
31129 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31130 PyObject *resultobj = 0;
31131 wxWindow *arg1 = (wxWindow *) 0 ;
31132 void *argp1 = 0 ;
31133 int res1 = 0 ;
31134 PyObject *swig_obj[1] ;
31135
31136 if (!args) SWIG_fail;
31137 swig_obj[0] = args;
31138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31139 if (!SWIG_IsOK(res1)) {
31140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31141 }
31142 arg1 = reinterpret_cast< wxWindow * >(argp1);
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 (arg1)->InvalidateBestSize();
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 resultobj = SWIG_Py_Void();
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = 0;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 wxSize *arg2 = 0 ;
31160 void *argp1 = 0 ;
31161 int res1 = 0 ;
31162 wxSize temp2 ;
31163 PyObject * obj0 = 0 ;
31164 PyObject * obj1 = 0 ;
31165 char * kwnames[] = {
31166 (char *) "self",(char *) "size", NULL
31167 };
31168
31169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31171 if (!SWIG_IsOK(res1)) {
31172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31173 }
31174 arg1 = reinterpret_cast< wxWindow * >(argp1);
31175 {
31176 arg2 = &temp2;
31177 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31178 }
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 resultobj = SWIG_Py_Void();
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31193 PyObject *resultobj = 0;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 wxSize result;
31196 void *argp1 = 0 ;
31197 int res1 = 0 ;
31198 PyObject *swig_obj[1] ;
31199
31200 if (!args) SWIG_fail;
31201 swig_obj[0] = args;
31202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31203 if (!SWIG_IsOK(res1)) {
31204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31205 }
31206 arg1 = reinterpret_cast< wxWindow * >(argp1);
31207 {
31208 PyThreadState* __tstate = wxPyBeginAllowThreads();
31209 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31221 PyObject *resultobj = 0;
31222 wxWindow *arg1 = (wxWindow *) 0 ;
31223 wxSize result;
31224 void *argp1 = 0 ;
31225 int res1 = 0 ;
31226 PyObject *swig_obj[1] ;
31227
31228 if (!args) SWIG_fail;
31229 swig_obj[0] = args;
31230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31231 if (!SWIG_IsOK(res1)) {
31232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31233 }
31234 arg1 = reinterpret_cast< wxWindow * >(argp1);
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 wxWindow *arg1 = (wxWindow *) 0 ;
31251 int arg2 = (int) wxBOTH ;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 int val2 ;
31255 int ecode2 = 0 ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 char * kwnames[] = {
31259 (char *) "self",(char *) "direction", NULL
31260 };
31261
31262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31264 if (!SWIG_IsOK(res1)) {
31265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31266 }
31267 arg1 = reinterpret_cast< wxWindow * >(argp1);
31268 if (obj1) {
31269 ecode2 = SWIG_AsVal_int(obj1, &val2);
31270 if (!SWIG_IsOK(ecode2)) {
31271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31272 }
31273 arg2 = static_cast< int >(val2);
31274 }
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 (arg1)->Center(arg2);
31278 wxPyEndAllowThreads(__tstate);
31279 if (PyErr_Occurred()) SWIG_fail;
31280 }
31281 resultobj = SWIG_Py_Void();
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31289 PyObject *resultobj = 0;
31290 wxWindow *arg1 = (wxWindow *) 0 ;
31291 int arg2 = (int) wxBOTH ;
31292 void *argp1 = 0 ;
31293 int res1 = 0 ;
31294 int val2 ;
31295 int ecode2 = 0 ;
31296 PyObject * obj0 = 0 ;
31297 PyObject * obj1 = 0 ;
31298 char * kwnames[] = {
31299 (char *) "self",(char *) "dir", NULL
31300 };
31301
31302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31304 if (!SWIG_IsOK(res1)) {
31305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31306 }
31307 arg1 = reinterpret_cast< wxWindow * >(argp1);
31308 if (obj1) {
31309 ecode2 = SWIG_AsVal_int(obj1, &val2);
31310 if (!SWIG_IsOK(ecode2)) {
31311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31312 }
31313 arg2 = static_cast< int >(val2);
31314 }
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 (arg1)->CenterOnParent(arg2);
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 resultobj = SWIG_Py_Void();
31322 return resultobj;
31323 fail:
31324 return NULL;
31325 }
31326
31327
31328 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31329 PyObject *resultobj = 0;
31330 wxWindow *arg1 = (wxWindow *) 0 ;
31331 void *argp1 = 0 ;
31332 int res1 = 0 ;
31333 PyObject *swig_obj[1] ;
31334
31335 if (!args) SWIG_fail;
31336 swig_obj[0] = args;
31337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31338 if (!SWIG_IsOK(res1)) {
31339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31340 }
31341 arg1 = reinterpret_cast< wxWindow * >(argp1);
31342 {
31343 PyThreadState* __tstate = wxPyBeginAllowThreads();
31344 (arg1)->Fit();
31345 wxPyEndAllowThreads(__tstate);
31346 if (PyErr_Occurred()) SWIG_fail;
31347 }
31348 resultobj = SWIG_Py_Void();
31349 return resultobj;
31350 fail:
31351 return NULL;
31352 }
31353
31354
31355 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31356 PyObject *resultobj = 0;
31357 wxWindow *arg1 = (wxWindow *) 0 ;
31358 void *argp1 = 0 ;
31359 int res1 = 0 ;
31360 PyObject *swig_obj[1] ;
31361
31362 if (!args) SWIG_fail;
31363 swig_obj[0] = args;
31364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31365 if (!SWIG_IsOK(res1)) {
31366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31367 }
31368 arg1 = reinterpret_cast< wxWindow * >(argp1);
31369 {
31370 PyThreadState* __tstate = wxPyBeginAllowThreads();
31371 (arg1)->FitInside();
31372 wxPyEndAllowThreads(__tstate);
31373 if (PyErr_Occurred()) SWIG_fail;
31374 }
31375 resultobj = SWIG_Py_Void();
31376 return resultobj;
31377 fail:
31378 return NULL;
31379 }
31380
31381
31382 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31383 PyObject *resultobj = 0;
31384 wxWindow *arg1 = (wxWindow *) 0 ;
31385 int arg2 ;
31386 int arg3 ;
31387 int arg4 = (int) -1 ;
31388 int arg5 = (int) -1 ;
31389 int arg6 = (int) -1 ;
31390 int arg7 = (int) -1 ;
31391 void *argp1 = 0 ;
31392 int res1 = 0 ;
31393 int val2 ;
31394 int ecode2 = 0 ;
31395 int val3 ;
31396 int ecode3 = 0 ;
31397 int val4 ;
31398 int ecode4 = 0 ;
31399 int val5 ;
31400 int ecode5 = 0 ;
31401 int val6 ;
31402 int ecode6 = 0 ;
31403 int val7 ;
31404 int ecode7 = 0 ;
31405 PyObject * obj0 = 0 ;
31406 PyObject * obj1 = 0 ;
31407 PyObject * obj2 = 0 ;
31408 PyObject * obj3 = 0 ;
31409 PyObject * obj4 = 0 ;
31410 PyObject * obj5 = 0 ;
31411 PyObject * obj6 = 0 ;
31412 char * kwnames[] = {
31413 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31414 };
31415
31416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31418 if (!SWIG_IsOK(res1)) {
31419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31420 }
31421 arg1 = reinterpret_cast< wxWindow * >(argp1);
31422 ecode2 = SWIG_AsVal_int(obj1, &val2);
31423 if (!SWIG_IsOK(ecode2)) {
31424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31425 }
31426 arg2 = static_cast< int >(val2);
31427 ecode3 = SWIG_AsVal_int(obj2, &val3);
31428 if (!SWIG_IsOK(ecode3)) {
31429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31430 }
31431 arg3 = static_cast< int >(val3);
31432 if (obj3) {
31433 ecode4 = SWIG_AsVal_int(obj3, &val4);
31434 if (!SWIG_IsOK(ecode4)) {
31435 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31436 }
31437 arg4 = static_cast< int >(val4);
31438 }
31439 if (obj4) {
31440 ecode5 = SWIG_AsVal_int(obj4, &val5);
31441 if (!SWIG_IsOK(ecode5)) {
31442 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31443 }
31444 arg5 = static_cast< int >(val5);
31445 }
31446 if (obj5) {
31447 ecode6 = SWIG_AsVal_int(obj5, &val6);
31448 if (!SWIG_IsOK(ecode6)) {
31449 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31450 }
31451 arg6 = static_cast< int >(val6);
31452 }
31453 if (obj6) {
31454 ecode7 = SWIG_AsVal_int(obj6, &val7);
31455 if (!SWIG_IsOK(ecode7)) {
31456 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31457 }
31458 arg7 = static_cast< int >(val7);
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_Py_Void();
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31474 PyObject *resultobj = 0;
31475 wxWindow *arg1 = (wxWindow *) 0 ;
31476 wxSize *arg2 = 0 ;
31477 wxSize const &arg3_defvalue = wxDefaultSize ;
31478 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31479 wxSize const &arg4_defvalue = wxDefaultSize ;
31480 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31481 void *argp1 = 0 ;
31482 int res1 = 0 ;
31483 wxSize temp2 ;
31484 wxSize temp3 ;
31485 wxSize temp4 ;
31486 PyObject * obj0 = 0 ;
31487 PyObject * obj1 = 0 ;
31488 PyObject * obj2 = 0 ;
31489 PyObject * obj3 = 0 ;
31490 char * kwnames[] = {
31491 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31492 };
31493
31494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31496 if (!SWIG_IsOK(res1)) {
31497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31498 }
31499 arg1 = reinterpret_cast< wxWindow * >(argp1);
31500 {
31501 arg2 = &temp2;
31502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31503 }
31504 if (obj2) {
31505 {
31506 arg3 = &temp3;
31507 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31508 }
31509 }
31510 if (obj3) {
31511 {
31512 arg4 = &temp4;
31513 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31514 }
31515 }
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 resultobj = SWIG_Py_Void();
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31530 PyObject *resultobj = 0;
31531 wxWindow *arg1 = (wxWindow *) 0 ;
31532 int arg2 ;
31533 int arg3 ;
31534 int arg4 = (int) -1 ;
31535 int arg5 = (int) -1 ;
31536 void *argp1 = 0 ;
31537 int res1 = 0 ;
31538 int val2 ;
31539 int ecode2 = 0 ;
31540 int val3 ;
31541 int ecode3 = 0 ;
31542 int val4 ;
31543 int ecode4 = 0 ;
31544 int val5 ;
31545 int ecode5 = 0 ;
31546 PyObject * obj0 = 0 ;
31547 PyObject * obj1 = 0 ;
31548 PyObject * obj2 = 0 ;
31549 PyObject * obj3 = 0 ;
31550 PyObject * obj4 = 0 ;
31551 char * kwnames[] = {
31552 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31553 };
31554
31555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31557 if (!SWIG_IsOK(res1)) {
31558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31559 }
31560 arg1 = reinterpret_cast< wxWindow * >(argp1);
31561 ecode2 = SWIG_AsVal_int(obj1, &val2);
31562 if (!SWIG_IsOK(ecode2)) {
31563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31564 }
31565 arg2 = static_cast< int >(val2);
31566 ecode3 = SWIG_AsVal_int(obj2, &val3);
31567 if (!SWIG_IsOK(ecode3)) {
31568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31569 }
31570 arg3 = static_cast< int >(val3);
31571 if (obj3) {
31572 ecode4 = SWIG_AsVal_int(obj3, &val4);
31573 if (!SWIG_IsOK(ecode4)) {
31574 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31575 }
31576 arg4 = static_cast< int >(val4);
31577 }
31578 if (obj4) {
31579 ecode5 = SWIG_AsVal_int(obj4, &val5);
31580 if (!SWIG_IsOK(ecode5)) {
31581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31582 }
31583 arg5 = static_cast< int >(val5);
31584 }
31585 {
31586 PyThreadState* __tstate = wxPyBeginAllowThreads();
31587 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31588 wxPyEndAllowThreads(__tstate);
31589 if (PyErr_Occurred()) SWIG_fail;
31590 }
31591 resultobj = SWIG_Py_Void();
31592 return resultobj;
31593 fail:
31594 return NULL;
31595 }
31596
31597
31598 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31599 PyObject *resultobj = 0;
31600 wxWindow *arg1 = (wxWindow *) 0 ;
31601 wxSize *arg2 = 0 ;
31602 wxSize const &arg3_defvalue = wxDefaultSize ;
31603 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31604 void *argp1 = 0 ;
31605 int res1 = 0 ;
31606 wxSize temp2 ;
31607 wxSize temp3 ;
31608 PyObject * obj0 = 0 ;
31609 PyObject * obj1 = 0 ;
31610 PyObject * obj2 = 0 ;
31611 char * kwnames[] = {
31612 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31613 };
31614
31615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31619 }
31620 arg1 = reinterpret_cast< wxWindow * >(argp1);
31621 {
31622 arg2 = &temp2;
31623 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31624 }
31625 if (obj2) {
31626 {
31627 arg3 = &temp3;
31628 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31629 }
31630 }
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 resultobj = SWIG_Py_Void();
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646 wxWindow *arg1 = (wxWindow *) 0 ;
31647 wxSize result;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 PyObject *swig_obj[1] ;
31651
31652 if (!args) SWIG_fail;
31653 swig_obj[0] = args;
31654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31657 }
31658 arg1 = reinterpret_cast< wxWindow * >(argp1);
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = ((wxWindow const *)arg1)->GetMaxSize();
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31673 PyObject *resultobj = 0;
31674 wxWindow *arg1 = (wxWindow *) 0 ;
31675 wxSize result;
31676 void *argp1 = 0 ;
31677 int res1 = 0 ;
31678 PyObject *swig_obj[1] ;
31679
31680 if (!args) SWIG_fail;
31681 swig_obj[0] = args;
31682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31683 if (!SWIG_IsOK(res1)) {
31684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31685 }
31686 arg1 = reinterpret_cast< wxWindow * >(argp1);
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = ((wxWindow const *)arg1)->GetMinSize();
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31701 PyObject *resultobj = 0;
31702 wxWindow *arg1 = (wxWindow *) 0 ;
31703 wxSize *arg2 = 0 ;
31704 void *argp1 = 0 ;
31705 int res1 = 0 ;
31706 wxSize temp2 ;
31707 PyObject * obj0 = 0 ;
31708 PyObject * obj1 = 0 ;
31709 char * kwnames[] = {
31710 (char *) "self",(char *) "minSize", NULL
31711 };
31712
31713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31715 if (!SWIG_IsOK(res1)) {
31716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31717 }
31718 arg1 = reinterpret_cast< wxWindow * >(argp1);
31719 {
31720 arg2 = &temp2;
31721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31722 }
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 (arg1)->SetMinSize((wxSize const &)*arg2);
31726 wxPyEndAllowThreads(__tstate);
31727 if (PyErr_Occurred()) SWIG_fail;
31728 }
31729 resultobj = SWIG_Py_Void();
31730 return resultobj;
31731 fail:
31732 return NULL;
31733 }
31734
31735
31736 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31737 PyObject *resultobj = 0;
31738 wxWindow *arg1 = (wxWindow *) 0 ;
31739 wxSize *arg2 = 0 ;
31740 void *argp1 = 0 ;
31741 int res1 = 0 ;
31742 wxSize temp2 ;
31743 PyObject * obj0 = 0 ;
31744 PyObject * obj1 = 0 ;
31745 char * kwnames[] = {
31746 (char *) "self",(char *) "maxSize", NULL
31747 };
31748
31749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31751 if (!SWIG_IsOK(res1)) {
31752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31753 }
31754 arg1 = reinterpret_cast< wxWindow * >(argp1);
31755 {
31756 arg2 = &temp2;
31757 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31758 }
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 (arg1)->SetMaxSize((wxSize const &)*arg2);
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 resultobj = SWIG_Py_Void();
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 PyObject *resultobj = 0;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 int result;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 PyObject *swig_obj[1] ;
31779
31780 if (!args) SWIG_fail;
31781 swig_obj[0] = args;
31782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31783 if (!SWIG_IsOK(res1)) {
31784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31785 }
31786 arg1 = reinterpret_cast< wxWindow * >(argp1);
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 resultobj = SWIG_From_int(static_cast< int >(result));
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 PyObject *resultobj = 0;
31802 wxWindow *arg1 = (wxWindow *) 0 ;
31803 int result;
31804 void *argp1 = 0 ;
31805 int res1 = 0 ;
31806 PyObject *swig_obj[1] ;
31807
31808 if (!args) SWIG_fail;
31809 swig_obj[0] = args;
31810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31811 if (!SWIG_IsOK(res1)) {
31812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31813 }
31814 arg1 = reinterpret_cast< wxWindow * >(argp1);
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 resultobj = SWIG_From_int(static_cast< int >(result));
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31829 PyObject *resultobj = 0;
31830 wxWindow *arg1 = (wxWindow *) 0 ;
31831 int result;
31832 void *argp1 = 0 ;
31833 int res1 = 0 ;
31834 PyObject *swig_obj[1] ;
31835
31836 if (!args) SWIG_fail;
31837 swig_obj[0] = args;
31838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31839 if (!SWIG_IsOK(res1)) {
31840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31841 }
31842 arg1 = reinterpret_cast< wxWindow * >(argp1);
31843 {
31844 PyThreadState* __tstate = wxPyBeginAllowThreads();
31845 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31846 wxPyEndAllowThreads(__tstate);
31847 if (PyErr_Occurred()) SWIG_fail;
31848 }
31849 resultobj = SWIG_From_int(static_cast< int >(result));
31850 return resultobj;
31851 fail:
31852 return NULL;
31853 }
31854
31855
31856 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31857 PyObject *resultobj = 0;
31858 wxWindow *arg1 = (wxWindow *) 0 ;
31859 int result;
31860 void *argp1 = 0 ;
31861 int res1 = 0 ;
31862 PyObject *swig_obj[1] ;
31863
31864 if (!args) SWIG_fail;
31865 swig_obj[0] = args;
31866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31867 if (!SWIG_IsOK(res1)) {
31868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31869 }
31870 arg1 = reinterpret_cast< wxWindow * >(argp1);
31871 {
31872 PyThreadState* __tstate = wxPyBeginAllowThreads();
31873 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31874 wxPyEndAllowThreads(__tstate);
31875 if (PyErr_Occurred()) SWIG_fail;
31876 }
31877 resultobj = SWIG_From_int(static_cast< int >(result));
31878 return resultobj;
31879 fail:
31880 return NULL;
31881 }
31882
31883
31884 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31885 PyObject *resultobj = 0;
31886 wxWindow *arg1 = (wxWindow *) 0 ;
31887 wxSize *arg2 = 0 ;
31888 void *argp1 = 0 ;
31889 int res1 = 0 ;
31890 wxSize temp2 ;
31891 PyObject * obj0 = 0 ;
31892 PyObject * obj1 = 0 ;
31893 char * kwnames[] = {
31894 (char *) "self",(char *) "size", NULL
31895 };
31896
31897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31899 if (!SWIG_IsOK(res1)) {
31900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31901 }
31902 arg1 = reinterpret_cast< wxWindow * >(argp1);
31903 {
31904 arg2 = &temp2;
31905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31906 }
31907 {
31908 PyThreadState* __tstate = wxPyBeginAllowThreads();
31909 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31910 wxPyEndAllowThreads(__tstate);
31911 if (PyErr_Occurred()) SWIG_fail;
31912 }
31913 resultobj = SWIG_Py_Void();
31914 return resultobj;
31915 fail:
31916 return NULL;
31917 }
31918
31919
31920 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31921 PyObject *resultobj = 0;
31922 wxWindow *arg1 = (wxWindow *) 0 ;
31923 int arg2 ;
31924 int arg3 ;
31925 void *argp1 = 0 ;
31926 int res1 = 0 ;
31927 int val2 ;
31928 int ecode2 = 0 ;
31929 int val3 ;
31930 int ecode3 = 0 ;
31931 PyObject * obj0 = 0 ;
31932 PyObject * obj1 = 0 ;
31933 PyObject * obj2 = 0 ;
31934 char * kwnames[] = {
31935 (char *) "self",(char *) "w",(char *) "h", NULL
31936 };
31937
31938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31940 if (!SWIG_IsOK(res1)) {
31941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31942 }
31943 arg1 = reinterpret_cast< wxWindow * >(argp1);
31944 ecode2 = SWIG_AsVal_int(obj1, &val2);
31945 if (!SWIG_IsOK(ecode2)) {
31946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31947 }
31948 arg2 = static_cast< int >(val2);
31949 ecode3 = SWIG_AsVal_int(obj2, &val3);
31950 if (!SWIG_IsOK(ecode3)) {
31951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31952 }
31953 arg3 = static_cast< int >(val3);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 (arg1)->SetVirtualSize(arg2,arg3);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_Py_Void();
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 PyObject *resultobj = 0;
31969 wxWindow *arg1 = (wxWindow *) 0 ;
31970 wxSize result;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 PyObject *swig_obj[1] ;
31974
31975 if (!args) SWIG_fail;
31976 swig_obj[0] = args;
31977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31978 if (!SWIG_IsOK(res1)) {
31979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31980 }
31981 arg1 = reinterpret_cast< wxWindow * >(argp1);
31982 {
31983 PyThreadState* __tstate = wxPyBeginAllowThreads();
31984 result = ((wxWindow const *)arg1)->GetVirtualSize();
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31989 return resultobj;
31990 fail:
31991 return NULL;
31992 }
31993
31994
31995 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31996 PyObject *resultobj = 0;
31997 wxWindow *arg1 = (wxWindow *) 0 ;
31998 int *arg2 = (int *) 0 ;
31999 int *arg3 = (int *) 0 ;
32000 void *argp1 = 0 ;
32001 int res1 = 0 ;
32002 int temp2 ;
32003 int res2 = SWIG_TMPOBJ ;
32004 int temp3 ;
32005 int res3 = SWIG_TMPOBJ ;
32006 PyObject *swig_obj[1] ;
32007
32008 arg2 = &temp2;
32009 arg3 = &temp3;
32010 if (!args) SWIG_fail;
32011 swig_obj[0] = args;
32012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 {
32018 PyThreadState* __tstate = wxPyBeginAllowThreads();
32019 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32020 wxPyEndAllowThreads(__tstate);
32021 if (PyErr_Occurred()) SWIG_fail;
32022 }
32023 resultobj = SWIG_Py_Void();
32024 if (SWIG_IsTmpObj(res2)) {
32025 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32026 } else {
32027 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32028 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32029 }
32030 if (SWIG_IsTmpObj(res3)) {
32031 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32032 } else {
32033 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32034 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32035 }
32036 return resultobj;
32037 fail:
32038 return NULL;
32039 }
32040
32041
32042 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32043 PyObject *resultobj = 0;
32044 wxWindow *arg1 = (wxWindow *) 0 ;
32045 wxSize result;
32046 void *argp1 = 0 ;
32047 int res1 = 0 ;
32048 PyObject *swig_obj[1] ;
32049
32050 if (!args) SWIG_fail;
32051 swig_obj[0] = args;
32052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32053 if (!SWIG_IsOK(res1)) {
32054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32055 }
32056 arg1 = reinterpret_cast< wxWindow * >(argp1);
32057 {
32058 PyThreadState* __tstate = wxPyBeginAllowThreads();
32059 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32060 wxPyEndAllowThreads(__tstate);
32061 if (PyErr_Occurred()) SWIG_fail;
32062 }
32063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32064 return resultobj;
32065 fail:
32066 return NULL;
32067 }
32068
32069
32070 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32071 PyObject *resultobj = 0;
32072 wxWindow *arg1 = (wxWindow *) 0 ;
32073 bool arg2 = (bool) true ;
32074 bool result;
32075 void *argp1 = 0 ;
32076 int res1 = 0 ;
32077 bool val2 ;
32078 int ecode2 = 0 ;
32079 PyObject * obj0 = 0 ;
32080 PyObject * obj1 = 0 ;
32081 char * kwnames[] = {
32082 (char *) "self",(char *) "show", NULL
32083 };
32084
32085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32087 if (!SWIG_IsOK(res1)) {
32088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32089 }
32090 arg1 = reinterpret_cast< wxWindow * >(argp1);
32091 if (obj1) {
32092 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32093 if (!SWIG_IsOK(ecode2)) {
32094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32095 }
32096 arg2 = static_cast< bool >(val2);
32097 }
32098 {
32099 PyThreadState* __tstate = wxPyBeginAllowThreads();
32100 result = (bool)(arg1)->Show(arg2);
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 {
32105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32106 }
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32114 PyObject *resultobj = 0;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 bool result;
32117 void *argp1 = 0 ;
32118 int res1 = 0 ;
32119 PyObject *swig_obj[1] ;
32120
32121 if (!args) SWIG_fail;
32122 swig_obj[0] = args;
32123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32124 if (!SWIG_IsOK(res1)) {
32125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32126 }
32127 arg1 = reinterpret_cast< wxWindow * >(argp1);
32128 {
32129 PyThreadState* __tstate = wxPyBeginAllowThreads();
32130 result = (bool)(arg1)->Hide();
32131 wxPyEndAllowThreads(__tstate);
32132 if (PyErr_Occurred()) SWIG_fail;
32133 }
32134 {
32135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32136 }
32137 return resultobj;
32138 fail:
32139 return NULL;
32140 }
32141
32142
32143 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32144 PyObject *resultobj = 0;
32145 wxWindow *arg1 = (wxWindow *) 0 ;
32146 bool arg2 = (bool) true ;
32147 bool result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 bool val2 ;
32151 int ecode2 = 0 ;
32152 PyObject * obj0 = 0 ;
32153 PyObject * obj1 = 0 ;
32154 char * kwnames[] = {
32155 (char *) "self",(char *) "enable", NULL
32156 };
32157
32158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32162 }
32163 arg1 = reinterpret_cast< wxWindow * >(argp1);
32164 if (obj1) {
32165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32166 if (!SWIG_IsOK(ecode2)) {
32167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32168 }
32169 arg2 = static_cast< bool >(val2);
32170 }
32171 {
32172 PyThreadState* __tstate = wxPyBeginAllowThreads();
32173 result = (bool)(arg1)->Enable(arg2);
32174 wxPyEndAllowThreads(__tstate);
32175 if (PyErr_Occurred()) SWIG_fail;
32176 }
32177 {
32178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32179 }
32180 return resultobj;
32181 fail:
32182 return NULL;
32183 }
32184
32185
32186 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 PyObject *resultobj = 0;
32188 wxWindow *arg1 = (wxWindow *) 0 ;
32189 bool result;
32190 void *argp1 = 0 ;
32191 int res1 = 0 ;
32192 PyObject *swig_obj[1] ;
32193
32194 if (!args) SWIG_fail;
32195 swig_obj[0] = args;
32196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32197 if (!SWIG_IsOK(res1)) {
32198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32199 }
32200 arg1 = reinterpret_cast< wxWindow * >(argp1);
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 result = (bool)(arg1)->Disable();
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 {
32208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32209 }
32210 return resultobj;
32211 fail:
32212 return NULL;
32213 }
32214
32215
32216 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32217 PyObject *resultobj = 0;
32218 wxWindow *arg1 = (wxWindow *) 0 ;
32219 bool result;
32220 void *argp1 = 0 ;
32221 int res1 = 0 ;
32222 PyObject *swig_obj[1] ;
32223
32224 if (!args) SWIG_fail;
32225 swig_obj[0] = args;
32226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32227 if (!SWIG_IsOK(res1)) {
32228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32229 }
32230 arg1 = reinterpret_cast< wxWindow * >(argp1);
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (bool)((wxWindow const *)arg1)->IsShown();
32234 wxPyEndAllowThreads(__tstate);
32235 if (PyErr_Occurred()) SWIG_fail;
32236 }
32237 {
32238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32239 }
32240 return resultobj;
32241 fail:
32242 return NULL;
32243 }
32244
32245
32246 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32247 PyObject *resultobj = 0;
32248 wxWindow *arg1 = (wxWindow *) 0 ;
32249 bool result;
32250 void *argp1 = 0 ;
32251 int res1 = 0 ;
32252 PyObject *swig_obj[1] ;
32253
32254 if (!args) SWIG_fail;
32255 swig_obj[0] = args;
32256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32257 if (!SWIG_IsOK(res1)) {
32258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32259 }
32260 arg1 = reinterpret_cast< wxWindow * >(argp1);
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32264 wxPyEndAllowThreads(__tstate);
32265 if (PyErr_Occurred()) SWIG_fail;
32266 }
32267 {
32268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32269 }
32270 return resultobj;
32271 fail:
32272 return NULL;
32273 }
32274
32275
32276 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32277 PyObject *resultobj = 0;
32278 wxWindow *arg1 = (wxWindow *) 0 ;
32279 long arg2 ;
32280 void *argp1 = 0 ;
32281 int res1 = 0 ;
32282 long val2 ;
32283 int ecode2 = 0 ;
32284 PyObject * obj0 = 0 ;
32285 PyObject * obj1 = 0 ;
32286 char * kwnames[] = {
32287 (char *) "self",(char *) "style", NULL
32288 };
32289
32290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32292 if (!SWIG_IsOK(res1)) {
32293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32294 }
32295 arg1 = reinterpret_cast< wxWindow * >(argp1);
32296 ecode2 = SWIG_AsVal_long(obj1, &val2);
32297 if (!SWIG_IsOK(ecode2)) {
32298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32299 }
32300 arg2 = static_cast< long >(val2);
32301 {
32302 PyThreadState* __tstate = wxPyBeginAllowThreads();
32303 (arg1)->SetWindowStyleFlag(arg2);
32304 wxPyEndAllowThreads(__tstate);
32305 if (PyErr_Occurred()) SWIG_fail;
32306 }
32307 resultobj = SWIG_Py_Void();
32308 return resultobj;
32309 fail:
32310 return NULL;
32311 }
32312
32313
32314 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32315 PyObject *resultobj = 0;
32316 wxWindow *arg1 = (wxWindow *) 0 ;
32317 long result;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 PyObject *swig_obj[1] ;
32321
32322 if (!args) SWIG_fail;
32323 swig_obj[0] = args;
32324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32325 if (!SWIG_IsOK(res1)) {
32326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32327 }
32328 arg1 = reinterpret_cast< wxWindow * >(argp1);
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = SWIG_From_long(static_cast< long >(result));
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32343 PyObject *resultobj = 0;
32344 wxWindow *arg1 = (wxWindow *) 0 ;
32345 int arg2 ;
32346 bool result;
32347 void *argp1 = 0 ;
32348 int res1 = 0 ;
32349 int val2 ;
32350 int ecode2 = 0 ;
32351 PyObject * obj0 = 0 ;
32352 PyObject * obj1 = 0 ;
32353 char * kwnames[] = {
32354 (char *) "self",(char *) "flag", NULL
32355 };
32356
32357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32359 if (!SWIG_IsOK(res1)) {
32360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32361 }
32362 arg1 = reinterpret_cast< wxWindow * >(argp1);
32363 ecode2 = SWIG_AsVal_int(obj1, &val2);
32364 if (!SWIG_IsOK(ecode2)) {
32365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32366 }
32367 arg2 = static_cast< int >(val2);
32368 {
32369 PyThreadState* __tstate = wxPyBeginAllowThreads();
32370 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32371 wxPyEndAllowThreads(__tstate);
32372 if (PyErr_Occurred()) SWIG_fail;
32373 }
32374 {
32375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32376 }
32377 return resultobj;
32378 fail:
32379 return NULL;
32380 }
32381
32382
32383 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32384 PyObject *resultobj = 0;
32385 wxWindow *arg1 = (wxWindow *) 0 ;
32386 bool result;
32387 void *argp1 = 0 ;
32388 int res1 = 0 ;
32389 PyObject *swig_obj[1] ;
32390
32391 if (!args) SWIG_fail;
32392 swig_obj[0] = args;
32393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32394 if (!SWIG_IsOK(res1)) {
32395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32396 }
32397 arg1 = reinterpret_cast< wxWindow * >(argp1);
32398 {
32399 PyThreadState* __tstate = wxPyBeginAllowThreads();
32400 result = (bool)((wxWindow const *)arg1)->IsRetained();
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 {
32405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32406 }
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj = 0;
32415 wxWindow *arg1 = (wxWindow *) 0 ;
32416 long arg2 ;
32417 void *argp1 = 0 ;
32418 int res1 = 0 ;
32419 long val2 ;
32420 int ecode2 = 0 ;
32421 PyObject * obj0 = 0 ;
32422 PyObject * obj1 = 0 ;
32423 char * kwnames[] = {
32424 (char *) "self",(char *) "exStyle", NULL
32425 };
32426
32427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32429 if (!SWIG_IsOK(res1)) {
32430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32431 }
32432 arg1 = reinterpret_cast< wxWindow * >(argp1);
32433 ecode2 = SWIG_AsVal_long(obj1, &val2);
32434 if (!SWIG_IsOK(ecode2)) {
32435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32436 }
32437 arg2 = static_cast< long >(val2);
32438 {
32439 PyThreadState* __tstate = wxPyBeginAllowThreads();
32440 (arg1)->SetExtraStyle(arg2);
32441 wxPyEndAllowThreads(__tstate);
32442 if (PyErr_Occurred()) SWIG_fail;
32443 }
32444 resultobj = SWIG_Py_Void();
32445 return resultobj;
32446 fail:
32447 return NULL;
32448 }
32449
32450
32451 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32452 PyObject *resultobj = 0;
32453 wxWindow *arg1 = (wxWindow *) 0 ;
32454 long result;
32455 void *argp1 = 0 ;
32456 int res1 = 0 ;
32457 PyObject *swig_obj[1] ;
32458
32459 if (!args) SWIG_fail;
32460 swig_obj[0] = args;
32461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32462 if (!SWIG_IsOK(res1)) {
32463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32464 }
32465 arg1 = reinterpret_cast< wxWindow * >(argp1);
32466 {
32467 PyThreadState* __tstate = wxPyBeginAllowThreads();
32468 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32469 wxPyEndAllowThreads(__tstate);
32470 if (PyErr_Occurred()) SWIG_fail;
32471 }
32472 resultobj = SWIG_From_long(static_cast< long >(result));
32473 return resultobj;
32474 fail:
32475 return NULL;
32476 }
32477
32478
32479 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32480 PyObject *resultobj = 0;
32481 wxWindow *arg1 = (wxWindow *) 0 ;
32482 bool arg2 = (bool) true ;
32483 void *argp1 = 0 ;
32484 int res1 = 0 ;
32485 bool val2 ;
32486 int ecode2 = 0 ;
32487 PyObject * obj0 = 0 ;
32488 PyObject * obj1 = 0 ;
32489 char * kwnames[] = {
32490 (char *) "self",(char *) "modal", NULL
32491 };
32492
32493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32495 if (!SWIG_IsOK(res1)) {
32496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32497 }
32498 arg1 = reinterpret_cast< wxWindow * >(argp1);
32499 if (obj1) {
32500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32501 if (!SWIG_IsOK(ecode2)) {
32502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32503 }
32504 arg2 = static_cast< bool >(val2);
32505 }
32506 {
32507 PyThreadState* __tstate = wxPyBeginAllowThreads();
32508 (arg1)->MakeModal(arg2);
32509 wxPyEndAllowThreads(__tstate);
32510 if (PyErr_Occurred()) SWIG_fail;
32511 }
32512 resultobj = SWIG_Py_Void();
32513 return resultobj;
32514 fail:
32515 return NULL;
32516 }
32517
32518
32519 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32520 PyObject *resultobj = 0;
32521 wxWindow *arg1 = (wxWindow *) 0 ;
32522 bool arg2 ;
32523 void *argp1 = 0 ;
32524 int res1 = 0 ;
32525 bool val2 ;
32526 int ecode2 = 0 ;
32527 PyObject * obj0 = 0 ;
32528 PyObject * obj1 = 0 ;
32529 char * kwnames[] = {
32530 (char *) "self",(char *) "enableTheme", NULL
32531 };
32532
32533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32537 }
32538 arg1 = reinterpret_cast< wxWindow * >(argp1);
32539 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32540 if (!SWIG_IsOK(ecode2)) {
32541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32542 }
32543 arg2 = static_cast< bool >(val2);
32544 {
32545 PyThreadState* __tstate = wxPyBeginAllowThreads();
32546 (arg1)->SetThemeEnabled(arg2);
32547 wxPyEndAllowThreads(__tstate);
32548 if (PyErr_Occurred()) SWIG_fail;
32549 }
32550 resultobj = SWIG_Py_Void();
32551 return resultobj;
32552 fail:
32553 return NULL;
32554 }
32555
32556
32557 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32558 PyObject *resultobj = 0;
32559 wxWindow *arg1 = (wxWindow *) 0 ;
32560 bool result;
32561 void *argp1 = 0 ;
32562 int res1 = 0 ;
32563 PyObject *swig_obj[1] ;
32564
32565 if (!args) SWIG_fail;
32566 swig_obj[0] = args;
32567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32570 }
32571 arg1 = reinterpret_cast< wxWindow * >(argp1);
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32575 wxPyEndAllowThreads(__tstate);
32576 if (PyErr_Occurred()) SWIG_fail;
32577 }
32578 {
32579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32580 }
32581 return resultobj;
32582 fail:
32583 return NULL;
32584 }
32585
32586
32587 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32588 PyObject *resultobj = 0;
32589 wxWindow *arg1 = (wxWindow *) 0 ;
32590 void *argp1 = 0 ;
32591 int res1 = 0 ;
32592 PyObject *swig_obj[1] ;
32593
32594 if (!args) SWIG_fail;
32595 swig_obj[0] = args;
32596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32597 if (!SWIG_IsOK(res1)) {
32598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32599 }
32600 arg1 = reinterpret_cast< wxWindow * >(argp1);
32601 {
32602 PyThreadState* __tstate = wxPyBeginAllowThreads();
32603 (arg1)->SetFocus();
32604 wxPyEndAllowThreads(__tstate);
32605 if (PyErr_Occurred()) SWIG_fail;
32606 }
32607 resultobj = SWIG_Py_Void();
32608 return resultobj;
32609 fail:
32610 return NULL;
32611 }
32612
32613
32614 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32615 PyObject *resultobj = 0;
32616 wxWindow *arg1 = (wxWindow *) 0 ;
32617 void *argp1 = 0 ;
32618 int res1 = 0 ;
32619 PyObject *swig_obj[1] ;
32620
32621 if (!args) SWIG_fail;
32622 swig_obj[0] = args;
32623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32624 if (!SWIG_IsOK(res1)) {
32625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32626 }
32627 arg1 = reinterpret_cast< wxWindow * >(argp1);
32628 {
32629 PyThreadState* __tstate = wxPyBeginAllowThreads();
32630 (arg1)->SetFocusFromKbd();
32631 wxPyEndAllowThreads(__tstate);
32632 if (PyErr_Occurred()) SWIG_fail;
32633 }
32634 resultobj = SWIG_Py_Void();
32635 return resultobj;
32636 fail:
32637 return NULL;
32638 }
32639
32640
32641 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32642 PyObject *resultobj = 0;
32643 wxWindow *result = 0 ;
32644
32645 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32646 {
32647 if (!wxPyCheckForApp()) SWIG_fail;
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 result = (wxWindow *)wxWindow::FindFocus();
32650 wxPyEndAllowThreads(__tstate);
32651 if (PyErr_Occurred()) SWIG_fail;
32652 }
32653 {
32654 resultobj = wxPyMake_wxObject(result, 0);
32655 }
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *resultobj = 0;
32664 wxWindow *arg1 = (wxWindow *) 0 ;
32665 bool result;
32666 void *argp1 = 0 ;
32667 int res1 = 0 ;
32668 PyObject *swig_obj[1] ;
32669
32670 if (!args) SWIG_fail;
32671 swig_obj[0] = args;
32672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32673 if (!SWIG_IsOK(res1)) {
32674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32675 }
32676 arg1 = reinterpret_cast< wxWindow * >(argp1);
32677 {
32678 PyThreadState* __tstate = wxPyBeginAllowThreads();
32679 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32680 wxPyEndAllowThreads(__tstate);
32681 if (PyErr_Occurred()) SWIG_fail;
32682 }
32683 {
32684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32685 }
32686 return resultobj;
32687 fail:
32688 return NULL;
32689 }
32690
32691
32692 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32693 PyObject *resultobj = 0;
32694 wxWindow *arg1 = (wxWindow *) 0 ;
32695 bool result;
32696 void *argp1 = 0 ;
32697 int res1 = 0 ;
32698 PyObject *swig_obj[1] ;
32699
32700 if (!args) SWIG_fail;
32701 swig_obj[0] = args;
32702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 {
32708 PyThreadState* __tstate = wxPyBeginAllowThreads();
32709 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32710 wxPyEndAllowThreads(__tstate);
32711 if (PyErr_Occurred()) SWIG_fail;
32712 }
32713 {
32714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32715 }
32716 return resultobj;
32717 fail:
32718 return NULL;
32719 }
32720
32721
32722 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32723 PyObject *resultobj = 0;
32724 wxWindow *arg1 = (wxWindow *) 0 ;
32725 wxWindow *result = 0 ;
32726 void *argp1 = 0 ;
32727 int res1 = 0 ;
32728 PyObject *swig_obj[1] ;
32729
32730 if (!args) SWIG_fail;
32731 swig_obj[0] = args;
32732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32733 if (!SWIG_IsOK(res1)) {
32734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32735 }
32736 arg1 = reinterpret_cast< wxWindow * >(argp1);
32737 {
32738 PyThreadState* __tstate = wxPyBeginAllowThreads();
32739 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32740 wxPyEndAllowThreads(__tstate);
32741 if (PyErr_Occurred()) SWIG_fail;
32742 }
32743 {
32744 resultobj = wxPyMake_wxObject(result, 0);
32745 }
32746 return resultobj;
32747 fail:
32748 return NULL;
32749 }
32750
32751
32752 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32753 PyObject *resultobj = 0;
32754 wxWindow *arg1 = (wxWindow *) 0 ;
32755 wxWindow *arg2 = (wxWindow *) 0 ;
32756 wxWindow *result = 0 ;
32757 void *argp1 = 0 ;
32758 int res1 = 0 ;
32759 void *argp2 = 0 ;
32760 int res2 = 0 ;
32761 PyObject * obj0 = 0 ;
32762 PyObject * obj1 = 0 ;
32763 char * kwnames[] = {
32764 (char *) "self",(char *) "child", NULL
32765 };
32766
32767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32769 if (!SWIG_IsOK(res1)) {
32770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32771 }
32772 arg1 = reinterpret_cast< wxWindow * >(argp1);
32773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32774 if (!SWIG_IsOK(res2)) {
32775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32776 }
32777 arg2 = reinterpret_cast< wxWindow * >(argp2);
32778 {
32779 PyThreadState* __tstate = wxPyBeginAllowThreads();
32780 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 {
32785 resultobj = wxPyMake_wxObject(result, 0);
32786 }
32787 return resultobj;
32788 fail:
32789 return NULL;
32790 }
32791
32792
32793 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32794 PyObject *resultobj = 0;
32795 wxWindow *arg1 = (wxWindow *) 0 ;
32796 wxWindow *arg2 = (wxWindow *) 0 ;
32797 void *argp1 = 0 ;
32798 int res1 = 0 ;
32799 void *argp2 = 0 ;
32800 int res2 = 0 ;
32801 PyObject * obj0 = 0 ;
32802 PyObject * obj1 = 0 ;
32803 char * kwnames[] = {
32804 (char *) "self",(char *) "win", NULL
32805 };
32806
32807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32809 if (!SWIG_IsOK(res1)) {
32810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32811 }
32812 arg1 = reinterpret_cast< wxWindow * >(argp1);
32813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32814 if (!SWIG_IsOK(res2)) {
32815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32816 }
32817 arg2 = reinterpret_cast< wxWindow * >(argp2);
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 (arg1)->SetTmpDefaultItem(arg2);
32821 wxPyEndAllowThreads(__tstate);
32822 if (PyErr_Occurred()) SWIG_fail;
32823 }
32824 resultobj = SWIG_Py_Void();
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32832 PyObject *resultobj = 0;
32833 wxWindow *arg1 = (wxWindow *) 0 ;
32834 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32835 bool result;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 int val2 ;
32839 int ecode2 = 0 ;
32840 PyObject * obj0 = 0 ;
32841 PyObject * obj1 = 0 ;
32842 char * kwnames[] = {
32843 (char *) "self",(char *) "flags", NULL
32844 };
32845
32846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32850 }
32851 arg1 = reinterpret_cast< wxWindow * >(argp1);
32852 if (obj1) {
32853 ecode2 = SWIG_AsVal_int(obj1, &val2);
32854 if (!SWIG_IsOK(ecode2)) {
32855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32856 }
32857 arg2 = static_cast< int >(val2);
32858 }
32859 {
32860 PyThreadState* __tstate = wxPyBeginAllowThreads();
32861 result = (bool)(arg1)->Navigate(arg2);
32862 wxPyEndAllowThreads(__tstate);
32863 if (PyErr_Occurred()) SWIG_fail;
32864 }
32865 {
32866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32867 }
32868 return resultobj;
32869 fail:
32870 return NULL;
32871 }
32872
32873
32874 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32875 PyObject *resultobj = 0;
32876 wxWindow *arg1 = (wxWindow *) 0 ;
32877 wxWindow *arg2 = (wxWindow *) 0 ;
32878 void *argp1 = 0 ;
32879 int res1 = 0 ;
32880 void *argp2 = 0 ;
32881 int res2 = 0 ;
32882 PyObject * obj0 = 0 ;
32883 PyObject * obj1 = 0 ;
32884 char * kwnames[] = {
32885 (char *) "self",(char *) "win", NULL
32886 };
32887
32888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32890 if (!SWIG_IsOK(res1)) {
32891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32892 }
32893 arg1 = reinterpret_cast< wxWindow * >(argp1);
32894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32895 if (!SWIG_IsOK(res2)) {
32896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32897 }
32898 arg2 = reinterpret_cast< wxWindow * >(argp2);
32899 {
32900 PyThreadState* __tstate = wxPyBeginAllowThreads();
32901 (arg1)->MoveAfterInTabOrder(arg2);
32902 wxPyEndAllowThreads(__tstate);
32903 if (PyErr_Occurred()) SWIG_fail;
32904 }
32905 resultobj = SWIG_Py_Void();
32906 return resultobj;
32907 fail:
32908 return NULL;
32909 }
32910
32911
32912 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32913 PyObject *resultobj = 0;
32914 wxWindow *arg1 = (wxWindow *) 0 ;
32915 wxWindow *arg2 = (wxWindow *) 0 ;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 void *argp2 = 0 ;
32919 int res2 = 0 ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 char * kwnames[] = {
32923 (char *) "self",(char *) "win", NULL
32924 };
32925
32926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32928 if (!SWIG_IsOK(res1)) {
32929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32930 }
32931 arg1 = reinterpret_cast< wxWindow * >(argp1);
32932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32933 if (!SWIG_IsOK(res2)) {
32934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32935 }
32936 arg2 = reinterpret_cast< wxWindow * >(argp2);
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 (arg1)->MoveBeforeInTabOrder(arg2);
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 resultobj = SWIG_Py_Void();
32944 return resultobj;
32945 fail:
32946 return NULL;
32947 }
32948
32949
32950 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32951 PyObject *resultobj = 0;
32952 wxWindow *arg1 = (wxWindow *) 0 ;
32953 PyObject *result = 0 ;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 PyObject *swig_obj[1] ;
32957
32958 if (!args) SWIG_fail;
32959 swig_obj[0] = args;
32960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32961 if (!SWIG_IsOK(res1)) {
32962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32963 }
32964 arg1 = reinterpret_cast< wxWindow * >(argp1);
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (PyObject *)wxWindow_GetChildren(arg1);
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 resultobj = result;
32972 return resultobj;
32973 fail:
32974 return NULL;
32975 }
32976
32977
32978 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32979 PyObject *resultobj = 0;
32980 wxWindow *arg1 = (wxWindow *) 0 ;
32981 wxWindow *result = 0 ;
32982 void *argp1 = 0 ;
32983 int res1 = 0 ;
32984 PyObject *swig_obj[1] ;
32985
32986 if (!args) SWIG_fail;
32987 swig_obj[0] = args;
32988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32989 if (!SWIG_IsOK(res1)) {
32990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32991 }
32992 arg1 = reinterpret_cast< wxWindow * >(argp1);
32993 {
32994 PyThreadState* __tstate = wxPyBeginAllowThreads();
32995 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32996 wxPyEndAllowThreads(__tstate);
32997 if (PyErr_Occurred()) SWIG_fail;
32998 }
32999 {
33000 resultobj = wxPyMake_wxObject(result, 0);
33001 }
33002 return resultobj;
33003 fail:
33004 return NULL;
33005 }
33006
33007
33008 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33009 PyObject *resultobj = 0;
33010 wxWindow *arg1 = (wxWindow *) 0 ;
33011 wxWindow *result = 0 ;
33012 void *argp1 = 0 ;
33013 int res1 = 0 ;
33014 PyObject *swig_obj[1] ;
33015
33016 if (!args) SWIG_fail;
33017 swig_obj[0] = args;
33018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res1)) {
33020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33021 }
33022 arg1 = reinterpret_cast< wxWindow * >(argp1);
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33026 wxPyEndAllowThreads(__tstate);
33027 if (PyErr_Occurred()) SWIG_fail;
33028 }
33029 {
33030 resultobj = wxPyMake_wxObject(result, 0);
33031 }
33032 return resultobj;
33033 fail:
33034 return NULL;
33035 }
33036
33037
33038 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33039 PyObject *resultobj = 0;
33040 wxWindow *arg1 = (wxWindow *) 0 ;
33041 bool result;
33042 void *argp1 = 0 ;
33043 int res1 = 0 ;
33044 PyObject *swig_obj[1] ;
33045
33046 if (!args) SWIG_fail;
33047 swig_obj[0] = args;
33048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33049 if (!SWIG_IsOK(res1)) {
33050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33051 }
33052 arg1 = reinterpret_cast< wxWindow * >(argp1);
33053 {
33054 PyThreadState* __tstate = wxPyBeginAllowThreads();
33055 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33056 wxPyEndAllowThreads(__tstate);
33057 if (PyErr_Occurred()) SWIG_fail;
33058 }
33059 {
33060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33061 }
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 wxWindow *arg2 = (wxWindow *) 0 ;
33072 bool result;
33073 void *argp1 = 0 ;
33074 int res1 = 0 ;
33075 void *argp2 = 0 ;
33076 int res2 = 0 ;
33077 PyObject * obj0 = 0 ;
33078 PyObject * obj1 = 0 ;
33079 char * kwnames[] = {
33080 (char *) "self",(char *) "newParent", NULL
33081 };
33082
33083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33085 if (!SWIG_IsOK(res1)) {
33086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33087 }
33088 arg1 = reinterpret_cast< wxWindow * >(argp1);
33089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33090 if (!SWIG_IsOK(res2)) {
33091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33092 }
33093 arg2 = reinterpret_cast< wxWindow * >(argp2);
33094 {
33095 PyThreadState* __tstate = wxPyBeginAllowThreads();
33096 result = (bool)(arg1)->Reparent(arg2);
33097 wxPyEndAllowThreads(__tstate);
33098 if (PyErr_Occurred()) SWIG_fail;
33099 }
33100 {
33101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33102 }
33103 return resultobj;
33104 fail:
33105 return NULL;
33106 }
33107
33108
33109 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj = 0;
33111 wxWindow *arg1 = (wxWindow *) 0 ;
33112 wxWindow *arg2 = (wxWindow *) 0 ;
33113 void *argp1 = 0 ;
33114 int res1 = 0 ;
33115 void *argp2 = 0 ;
33116 int res2 = 0 ;
33117 PyObject * obj0 = 0 ;
33118 PyObject * obj1 = 0 ;
33119 char * kwnames[] = {
33120 (char *) "self",(char *) "child", NULL
33121 };
33122
33123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33125 if (!SWIG_IsOK(res1)) {
33126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33127 }
33128 arg1 = reinterpret_cast< wxWindow * >(argp1);
33129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33130 if (!SWIG_IsOK(res2)) {
33131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33132 }
33133 arg2 = reinterpret_cast< wxWindow * >(argp2);
33134 {
33135 PyThreadState* __tstate = wxPyBeginAllowThreads();
33136 (arg1)->AddChild(arg2);
33137 wxPyEndAllowThreads(__tstate);
33138 if (PyErr_Occurred()) SWIG_fail;
33139 }
33140 resultobj = SWIG_Py_Void();
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33148 PyObject *resultobj = 0;
33149 wxWindow *arg1 = (wxWindow *) 0 ;
33150 wxWindow *arg2 = (wxWindow *) 0 ;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 void *argp2 = 0 ;
33154 int res2 = 0 ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "child", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33168 if (!SWIG_IsOK(res2)) {
33169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33170 }
33171 arg2 = reinterpret_cast< wxWindow * >(argp2);
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 (arg1)->RemoveChild(arg2);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 resultobj = SWIG_Py_Void();
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33186 PyObject *resultobj = 0;
33187 wxWindow *arg1 = (wxWindow *) 0 ;
33188 bool arg2 ;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 bool val2 ;
33192 int ecode2 = 0 ;
33193 PyObject * obj0 = 0 ;
33194 PyObject * obj1 = 0 ;
33195 char * kwnames[] = {
33196 (char *) "self",(char *) "on", NULL
33197 };
33198
33199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33201 if (!SWIG_IsOK(res1)) {
33202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33203 }
33204 arg1 = reinterpret_cast< wxWindow * >(argp1);
33205 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33206 if (!SWIG_IsOK(ecode2)) {
33207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33208 }
33209 arg2 = static_cast< bool >(val2);
33210 {
33211 PyThreadState* __tstate = wxPyBeginAllowThreads();
33212 wxWindow_SetDoubleBuffered(arg1,arg2);
33213 wxPyEndAllowThreads(__tstate);
33214 if (PyErr_Occurred()) SWIG_fail;
33215 }
33216 resultobj = SWIG_Py_Void();
33217 return resultobj;
33218 fail:
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33224 PyObject *resultobj = 0;
33225 wxWindow *arg1 = (wxWindow *) 0 ;
33226 long arg2 ;
33227 wxWindow *result = 0 ;
33228 void *argp1 = 0 ;
33229 int res1 = 0 ;
33230 long val2 ;
33231 int ecode2 = 0 ;
33232 PyObject * obj0 = 0 ;
33233 PyObject * obj1 = 0 ;
33234 char * kwnames[] = {
33235 (char *) "self",(char *) "winid", NULL
33236 };
33237
33238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33240 if (!SWIG_IsOK(res1)) {
33241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33242 }
33243 arg1 = reinterpret_cast< wxWindow * >(argp1);
33244 ecode2 = SWIG_AsVal_long(obj1, &val2);
33245 if (!SWIG_IsOK(ecode2)) {
33246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33247 }
33248 arg2 = static_cast< long >(val2);
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (wxWindow *)(arg1)->FindWindow(arg2);
33252 wxPyEndAllowThreads(__tstate);
33253 if (PyErr_Occurred()) SWIG_fail;
33254 }
33255 {
33256 resultobj = wxPyMake_wxObject(result, 0);
33257 }
33258 return resultobj;
33259 fail:
33260 return NULL;
33261 }
33262
33263
33264 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33265 PyObject *resultobj = 0;
33266 wxWindow *arg1 = (wxWindow *) 0 ;
33267 wxString *arg2 = 0 ;
33268 wxWindow *result = 0 ;
33269 void *argp1 = 0 ;
33270 int res1 = 0 ;
33271 bool temp2 = false ;
33272 PyObject * obj0 = 0 ;
33273 PyObject * obj1 = 0 ;
33274 char * kwnames[] = {
33275 (char *) "self",(char *) "name", NULL
33276 };
33277
33278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33280 if (!SWIG_IsOK(res1)) {
33281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33282 }
33283 arg1 = reinterpret_cast< wxWindow * >(argp1);
33284 {
33285 arg2 = wxString_in_helper(obj1);
33286 if (arg2 == NULL) SWIG_fail;
33287 temp2 = true;
33288 }
33289 {
33290 PyThreadState* __tstate = wxPyBeginAllowThreads();
33291 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33292 wxPyEndAllowThreads(__tstate);
33293 if (PyErr_Occurred()) SWIG_fail;
33294 }
33295 {
33296 resultobj = wxPyMake_wxObject(result, 0);
33297 }
33298 {
33299 if (temp2)
33300 delete arg2;
33301 }
33302 return resultobj;
33303 fail:
33304 {
33305 if (temp2)
33306 delete arg2;
33307 }
33308 return NULL;
33309 }
33310
33311
33312 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33313 PyObject *resultobj = 0;
33314 wxWindow *arg1 = (wxWindow *) 0 ;
33315 wxEvtHandler *result = 0 ;
33316 void *argp1 = 0 ;
33317 int res1 = 0 ;
33318 PyObject *swig_obj[1] ;
33319
33320 if (!args) SWIG_fail;
33321 swig_obj[0] = args;
33322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33323 if (!SWIG_IsOK(res1)) {
33324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33325 }
33326 arg1 = reinterpret_cast< wxWindow * >(argp1);
33327 {
33328 PyThreadState* __tstate = wxPyBeginAllowThreads();
33329 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 {
33334 resultobj = wxPyMake_wxObject(result, 0);
33335 }
33336 return resultobj;
33337 fail:
33338 return NULL;
33339 }
33340
33341
33342 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33343 PyObject *resultobj = 0;
33344 wxWindow *arg1 = (wxWindow *) 0 ;
33345 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33346 void *argp1 = 0 ;
33347 int res1 = 0 ;
33348 void *argp2 = 0 ;
33349 int res2 = 0 ;
33350 PyObject * obj0 = 0 ;
33351 PyObject * obj1 = 0 ;
33352 char * kwnames[] = {
33353 (char *) "self",(char *) "handler", NULL
33354 };
33355
33356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33363 if (!SWIG_IsOK(res2)) {
33364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33365 }
33366 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 (arg1)->SetEventHandler(arg2);
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_Py_Void();
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33381 PyObject *resultobj = 0;
33382 wxWindow *arg1 = (wxWindow *) 0 ;
33383 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33384 void *argp1 = 0 ;
33385 int res1 = 0 ;
33386 void *argp2 = 0 ;
33387 int res2 = 0 ;
33388 PyObject * obj0 = 0 ;
33389 PyObject * obj1 = 0 ;
33390 char * kwnames[] = {
33391 (char *) "self",(char *) "handler", NULL
33392 };
33393
33394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33396 if (!SWIG_IsOK(res1)) {
33397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33398 }
33399 arg1 = reinterpret_cast< wxWindow * >(argp1);
33400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33401 if (!SWIG_IsOK(res2)) {
33402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33403 }
33404 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 (arg1)->PushEventHandler(arg2);
33408 wxPyEndAllowThreads(__tstate);
33409 if (PyErr_Occurred()) SWIG_fail;
33410 }
33411 resultobj = SWIG_Py_Void();
33412 return resultobj;
33413 fail:
33414 return NULL;
33415 }
33416
33417
33418 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33419 PyObject *resultobj = 0;
33420 wxWindow *arg1 = (wxWindow *) 0 ;
33421 bool arg2 = (bool) false ;
33422 wxEvtHandler *result = 0 ;
33423 void *argp1 = 0 ;
33424 int res1 = 0 ;
33425 bool val2 ;
33426 int ecode2 = 0 ;
33427 PyObject * obj0 = 0 ;
33428 PyObject * obj1 = 0 ;
33429 char * kwnames[] = {
33430 (char *) "self",(char *) "deleteHandler", NULL
33431 };
33432
33433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33435 if (!SWIG_IsOK(res1)) {
33436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33437 }
33438 arg1 = reinterpret_cast< wxWindow * >(argp1);
33439 if (obj1) {
33440 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33441 if (!SWIG_IsOK(ecode2)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33443 }
33444 arg2 = static_cast< bool >(val2);
33445 }
33446 {
33447 PyThreadState* __tstate = wxPyBeginAllowThreads();
33448 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33449 wxPyEndAllowThreads(__tstate);
33450 if (PyErr_Occurred()) SWIG_fail;
33451 }
33452 {
33453 resultobj = wxPyMake_wxObject(result, 0);
33454 }
33455 return resultobj;
33456 fail:
33457 return NULL;
33458 }
33459
33460
33461 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33462 PyObject *resultobj = 0;
33463 wxWindow *arg1 = (wxWindow *) 0 ;
33464 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33465 bool result;
33466 void *argp1 = 0 ;
33467 int res1 = 0 ;
33468 void *argp2 = 0 ;
33469 int res2 = 0 ;
33470 PyObject * obj0 = 0 ;
33471 PyObject * obj1 = 0 ;
33472 char * kwnames[] = {
33473 (char *) "self",(char *) "handler", NULL
33474 };
33475
33476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33478 if (!SWIG_IsOK(res1)) {
33479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33480 }
33481 arg1 = reinterpret_cast< wxWindow * >(argp1);
33482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33483 if (!SWIG_IsOK(res2)) {
33484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33485 }
33486 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33487 {
33488 PyThreadState* __tstate = wxPyBeginAllowThreads();
33489 result = (bool)(arg1)->RemoveEventHandler(arg2);
33490 wxPyEndAllowThreads(__tstate);
33491 if (PyErr_Occurred()) SWIG_fail;
33492 }
33493 {
33494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33495 }
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj = 0;
33504 wxWindow *arg1 = (wxWindow *) 0 ;
33505 wxValidator *arg2 = 0 ;
33506 void *argp1 = 0 ;
33507 int res1 = 0 ;
33508 void *argp2 = 0 ;
33509 int res2 = 0 ;
33510 PyObject * obj0 = 0 ;
33511 PyObject * obj1 = 0 ;
33512 char * kwnames[] = {
33513 (char *) "self",(char *) "validator", NULL
33514 };
33515
33516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33518 if (!SWIG_IsOK(res1)) {
33519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33520 }
33521 arg1 = reinterpret_cast< wxWindow * >(argp1);
33522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33523 if (!SWIG_IsOK(res2)) {
33524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33525 }
33526 if (!argp2) {
33527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33528 }
33529 arg2 = reinterpret_cast< wxValidator * >(argp2);
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 (arg1)->SetValidator((wxValidator const &)*arg2);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 resultobj = SWIG_Py_Void();
33537 return resultobj;
33538 fail:
33539 return NULL;
33540 }
33541
33542
33543 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33544 PyObject *resultobj = 0;
33545 wxWindow *arg1 = (wxWindow *) 0 ;
33546 wxValidator *result = 0 ;
33547 void *argp1 = 0 ;
33548 int res1 = 0 ;
33549 PyObject *swig_obj[1] ;
33550
33551 if (!args) SWIG_fail;
33552 swig_obj[0] = args;
33553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33554 if (!SWIG_IsOK(res1)) {
33555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33556 }
33557 arg1 = reinterpret_cast< wxWindow * >(argp1);
33558 {
33559 PyThreadState* __tstate = wxPyBeginAllowThreads();
33560 result = (wxValidator *)(arg1)->GetValidator();
33561 wxPyEndAllowThreads(__tstate);
33562 if (PyErr_Occurred()) SWIG_fail;
33563 }
33564 {
33565 resultobj = wxPyMake_wxObject(result, (bool)0);
33566 }
33567 return resultobj;
33568 fail:
33569 return NULL;
33570 }
33571
33572
33573 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33574 PyObject *resultobj = 0;
33575 wxWindow *arg1 = (wxWindow *) 0 ;
33576 bool result;
33577 void *argp1 = 0 ;
33578 int res1 = 0 ;
33579 PyObject *swig_obj[1] ;
33580
33581 if (!args) SWIG_fail;
33582 swig_obj[0] = args;
33583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33584 if (!SWIG_IsOK(res1)) {
33585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33586 }
33587 arg1 = reinterpret_cast< wxWindow * >(argp1);
33588 {
33589 PyThreadState* __tstate = wxPyBeginAllowThreads();
33590 result = (bool)(arg1)->Validate();
33591 wxPyEndAllowThreads(__tstate);
33592 if (PyErr_Occurred()) SWIG_fail;
33593 }
33594 {
33595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33596 }
33597 return resultobj;
33598 fail:
33599 return NULL;
33600 }
33601
33602
33603 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33604 PyObject *resultobj = 0;
33605 wxWindow *arg1 = (wxWindow *) 0 ;
33606 bool result;
33607 void *argp1 = 0 ;
33608 int res1 = 0 ;
33609 PyObject *swig_obj[1] ;
33610
33611 if (!args) SWIG_fail;
33612 swig_obj[0] = args;
33613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33614 if (!SWIG_IsOK(res1)) {
33615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33616 }
33617 arg1 = reinterpret_cast< wxWindow * >(argp1);
33618 {
33619 PyThreadState* __tstate = wxPyBeginAllowThreads();
33620 result = (bool)(arg1)->TransferDataToWindow();
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 {
33625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33626 }
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33634 PyObject *resultobj = 0;
33635 wxWindow *arg1 = (wxWindow *) 0 ;
33636 bool result;
33637 void *argp1 = 0 ;
33638 int res1 = 0 ;
33639 PyObject *swig_obj[1] ;
33640
33641 if (!args) SWIG_fail;
33642 swig_obj[0] = args;
33643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33644 if (!SWIG_IsOK(res1)) {
33645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33646 }
33647 arg1 = reinterpret_cast< wxWindow * >(argp1);
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 result = (bool)(arg1)->TransferDataFromWindow();
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 {
33655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33656 }
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 PyObject *resultobj = 0;
33665 wxWindow *arg1 = (wxWindow *) 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_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 (arg1)->InitDialog();
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 resultobj = SWIG_Py_Void();
33684 return resultobj;
33685 fail:
33686 return NULL;
33687 }
33688
33689
33690 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33691 PyObject *resultobj = 0;
33692 wxWindow *arg1 = (wxWindow *) 0 ;
33693 wxAcceleratorTable *arg2 = 0 ;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 void *argp2 = 0 ;
33697 int res2 = 0 ;
33698 PyObject * obj0 = 0 ;
33699 PyObject * obj1 = 0 ;
33700 char * kwnames[] = {
33701 (char *) "self",(char *) "accel", NULL
33702 };
33703
33704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33708 }
33709 arg1 = reinterpret_cast< wxWindow * >(argp1);
33710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33711 if (!SWIG_IsOK(res2)) {
33712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33713 }
33714 if (!argp2) {
33715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33716 }
33717 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33718 {
33719 PyThreadState* __tstate = wxPyBeginAllowThreads();
33720 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33721 wxPyEndAllowThreads(__tstate);
33722 if (PyErr_Occurred()) SWIG_fail;
33723 }
33724 resultobj = SWIG_Py_Void();
33725 return resultobj;
33726 fail:
33727 return NULL;
33728 }
33729
33730
33731 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33732 PyObject *resultobj = 0;
33733 wxWindow *arg1 = (wxWindow *) 0 ;
33734 wxAcceleratorTable *result = 0 ;
33735 void *argp1 = 0 ;
33736 int res1 = 0 ;
33737 PyObject *swig_obj[1] ;
33738
33739 if (!args) SWIG_fail;
33740 swig_obj[0] = args;
33741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33742 if (!SWIG_IsOK(res1)) {
33743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33744 }
33745 arg1 = reinterpret_cast< wxWindow * >(argp1);
33746 {
33747 PyThreadState* __tstate = wxPyBeginAllowThreads();
33748 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33749 wxPyEndAllowThreads(__tstate);
33750 if (PyErr_Occurred()) SWIG_fail;
33751 }
33752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33753 return resultobj;
33754 fail:
33755 return NULL;
33756 }
33757
33758
33759 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33760 PyObject *resultobj = 0;
33761 wxWindow *arg1 = (wxWindow *) 0 ;
33762 int arg2 ;
33763 int arg3 ;
33764 int arg4 ;
33765 bool result;
33766 void *argp1 = 0 ;
33767 int res1 = 0 ;
33768 int val2 ;
33769 int ecode2 = 0 ;
33770 int val3 ;
33771 int ecode3 = 0 ;
33772 int val4 ;
33773 int ecode4 = 0 ;
33774 PyObject * obj0 = 0 ;
33775 PyObject * obj1 = 0 ;
33776 PyObject * obj2 = 0 ;
33777 PyObject * obj3 = 0 ;
33778 char * kwnames[] = {
33779 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33780 };
33781
33782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33784 if (!SWIG_IsOK(res1)) {
33785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33786 }
33787 arg1 = reinterpret_cast< wxWindow * >(argp1);
33788 ecode2 = SWIG_AsVal_int(obj1, &val2);
33789 if (!SWIG_IsOK(ecode2)) {
33790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33791 }
33792 arg2 = static_cast< int >(val2);
33793 ecode3 = SWIG_AsVal_int(obj2, &val3);
33794 if (!SWIG_IsOK(ecode3)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33796 }
33797 arg3 = static_cast< int >(val3);
33798 ecode4 = SWIG_AsVal_int(obj3, &val4);
33799 if (!SWIG_IsOK(ecode4)) {
33800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33801 }
33802 arg4 = static_cast< int >(val4);
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 {
33810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33811 }
33812 return resultobj;
33813 fail:
33814 return NULL;
33815 }
33816
33817
33818 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33819 PyObject *resultobj = 0;
33820 wxWindow *arg1 = (wxWindow *) 0 ;
33821 int arg2 ;
33822 bool result;
33823 void *argp1 = 0 ;
33824 int res1 = 0 ;
33825 int val2 ;
33826 int ecode2 = 0 ;
33827 PyObject * obj0 = 0 ;
33828 PyObject * obj1 = 0 ;
33829 char * kwnames[] = {
33830 (char *) "self",(char *) "hotkeyId", NULL
33831 };
33832
33833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33837 }
33838 arg1 = reinterpret_cast< wxWindow * >(argp1);
33839 ecode2 = SWIG_AsVal_int(obj1, &val2);
33840 if (!SWIG_IsOK(ecode2)) {
33841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33842 }
33843 arg2 = static_cast< int >(val2);
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 {
33851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33852 }
33853 return resultobj;
33854 fail:
33855 return NULL;
33856 }
33857
33858
33859 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33860 PyObject *resultobj = 0;
33861 wxWindow *arg1 = (wxWindow *) 0 ;
33862 wxPoint *arg2 = 0 ;
33863 wxPoint result;
33864 void *argp1 = 0 ;
33865 int res1 = 0 ;
33866 wxPoint temp2 ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 char * kwnames[] = {
33870 (char *) "self",(char *) "pt", NULL
33871 };
33872
33873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33875 if (!SWIG_IsOK(res1)) {
33876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33877 }
33878 arg1 = reinterpret_cast< wxWindow * >(argp1);
33879 {
33880 arg2 = &temp2;
33881 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33882 }
33883 {
33884 PyThreadState* __tstate = wxPyBeginAllowThreads();
33885 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33890 return resultobj;
33891 fail:
33892 return NULL;
33893 }
33894
33895
33896 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33897 PyObject *resultobj = 0;
33898 wxWindow *arg1 = (wxWindow *) 0 ;
33899 wxSize *arg2 = 0 ;
33900 wxSize result;
33901 void *argp1 = 0 ;
33902 int res1 = 0 ;
33903 wxSize temp2 ;
33904 PyObject * obj0 = 0 ;
33905 PyObject * obj1 = 0 ;
33906 char * kwnames[] = {
33907 (char *) "self",(char *) "sz", NULL
33908 };
33909
33910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33912 if (!SWIG_IsOK(res1)) {
33913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33914 }
33915 arg1 = reinterpret_cast< wxWindow * >(argp1);
33916 {
33917 arg2 = &temp2;
33918 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33919 }
33920 {
33921 PyThreadState* __tstate = wxPyBeginAllowThreads();
33922 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33923 wxPyEndAllowThreads(__tstate);
33924 if (PyErr_Occurred()) SWIG_fail;
33925 }
33926 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33934 PyObject *resultobj = 0;
33935 wxWindow *arg1 = (wxWindow *) 0 ;
33936 wxPoint *arg2 = 0 ;
33937 wxPoint result;
33938 void *argp1 = 0 ;
33939 int res1 = 0 ;
33940 wxPoint temp2 ;
33941 PyObject * obj0 = 0 ;
33942 PyObject * obj1 = 0 ;
33943 char * kwnames[] = {
33944 (char *) "self",(char *) "pt", NULL
33945 };
33946
33947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33949 if (!SWIG_IsOK(res1)) {
33950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33951 }
33952 arg1 = reinterpret_cast< wxWindow * >(argp1);
33953 {
33954 arg2 = &temp2;
33955 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33956 }
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33964 return resultobj;
33965 fail:
33966 return NULL;
33967 }
33968
33969
33970 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33971 PyObject *resultobj = 0;
33972 wxWindow *arg1 = (wxWindow *) 0 ;
33973 wxSize *arg2 = 0 ;
33974 wxSize result;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 wxSize temp2 ;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char * kwnames[] = {
33981 (char *) "self",(char *) "sz", NULL
33982 };
33983
33984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33986 if (!SWIG_IsOK(res1)) {
33987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33988 }
33989 arg1 = reinterpret_cast< wxWindow * >(argp1);
33990 {
33991 arg2 = &temp2;
33992 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33993 }
33994 {
33995 PyThreadState* __tstate = wxPyBeginAllowThreads();
33996 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33997 wxPyEndAllowThreads(__tstate);
33998 if (PyErr_Occurred()) SWIG_fail;
33999 }
34000 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj = 0;
34009 wxWindow *arg1 = (wxWindow *) 0 ;
34010 wxPoint *arg2 = 0 ;
34011 wxPoint result;
34012 void *argp1 = 0 ;
34013 int res1 = 0 ;
34014 wxPoint temp2 ;
34015 PyObject * obj0 = 0 ;
34016 PyObject * obj1 = 0 ;
34017 char * kwnames[] = {
34018 (char *) "self",(char *) "pt", NULL
34019 };
34020
34021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34023 if (!SWIG_IsOK(res1)) {
34024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34025 }
34026 arg1 = reinterpret_cast< wxWindow * >(argp1);
34027 {
34028 arg2 = &temp2;
34029 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34030 }
34031 {
34032 PyThreadState* __tstate = wxPyBeginAllowThreads();
34033 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34038 return resultobj;
34039 fail:
34040 return NULL;
34041 }
34042
34043
34044 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34045 PyObject *resultobj = 0;
34046 wxWindow *arg1 = (wxWindow *) 0 ;
34047 wxSize *arg2 = 0 ;
34048 wxSize result;
34049 void *argp1 = 0 ;
34050 int res1 = 0 ;
34051 wxSize temp2 ;
34052 PyObject * obj0 = 0 ;
34053 PyObject * obj1 = 0 ;
34054 char * kwnames[] = {
34055 (char *) "self",(char *) "sz", NULL
34056 };
34057
34058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34062 }
34063 arg1 = reinterpret_cast< wxWindow * >(argp1);
34064 {
34065 arg2 = &temp2;
34066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34067 }
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34082 PyObject *resultobj = 0;
34083 wxWindow *arg1 = (wxWindow *) 0 ;
34084 int arg2 ;
34085 int arg3 ;
34086 void *argp1 = 0 ;
34087 int res1 = 0 ;
34088 int val2 ;
34089 int ecode2 = 0 ;
34090 int val3 ;
34091 int ecode3 = 0 ;
34092 PyObject * obj0 = 0 ;
34093 PyObject * obj1 = 0 ;
34094 PyObject * obj2 = 0 ;
34095 char * kwnames[] = {
34096 (char *) "self",(char *) "x",(char *) "y", NULL
34097 };
34098
34099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34101 if (!SWIG_IsOK(res1)) {
34102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34103 }
34104 arg1 = reinterpret_cast< wxWindow * >(argp1);
34105 ecode2 = SWIG_AsVal_int(obj1, &val2);
34106 if (!SWIG_IsOK(ecode2)) {
34107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34108 }
34109 arg2 = static_cast< int >(val2);
34110 ecode3 = SWIG_AsVal_int(obj2, &val3);
34111 if (!SWIG_IsOK(ecode3)) {
34112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34113 }
34114 arg3 = static_cast< int >(val3);
34115 {
34116 PyThreadState* __tstate = wxPyBeginAllowThreads();
34117 (arg1)->WarpPointer(arg2,arg3);
34118 wxPyEndAllowThreads(__tstate);
34119 if (PyErr_Occurred()) SWIG_fail;
34120 }
34121 resultobj = SWIG_Py_Void();
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34129 PyObject *resultobj = 0;
34130 wxWindow *arg1 = (wxWindow *) 0 ;
34131 void *argp1 = 0 ;
34132 int res1 = 0 ;
34133 PyObject *swig_obj[1] ;
34134
34135 if (!args) SWIG_fail;
34136 swig_obj[0] = args;
34137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34140 }
34141 arg1 = reinterpret_cast< wxWindow * >(argp1);
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 (arg1)->CaptureMouse();
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 resultobj = SWIG_Py_Void();
34149 return resultobj;
34150 fail:
34151 return NULL;
34152 }
34153
34154
34155 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34156 PyObject *resultobj = 0;
34157 wxWindow *arg1 = (wxWindow *) 0 ;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 PyObject *swig_obj[1] ;
34161
34162 if (!args) SWIG_fail;
34163 swig_obj[0] = args;
34164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34165 if (!SWIG_IsOK(res1)) {
34166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34167 }
34168 arg1 = reinterpret_cast< wxWindow * >(argp1);
34169 {
34170 PyThreadState* __tstate = wxPyBeginAllowThreads();
34171 (arg1)->ReleaseMouse();
34172 wxPyEndAllowThreads(__tstate);
34173 if (PyErr_Occurred()) SWIG_fail;
34174 }
34175 resultobj = SWIG_Py_Void();
34176 return resultobj;
34177 fail:
34178 return NULL;
34179 }
34180
34181
34182 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 PyObject *resultobj = 0;
34184 wxWindow *result = 0 ;
34185
34186 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34187 {
34188 if (!wxPyCheckForApp()) SWIG_fail;
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = (wxWindow *)wxWindow::GetCapture();
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = wxPyMake_wxObject(result, 0);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34204 PyObject *resultobj = 0;
34205 wxWindow *arg1 = (wxWindow *) 0 ;
34206 bool result;
34207 void *argp1 = 0 ;
34208 int res1 = 0 ;
34209 PyObject *swig_obj[1] ;
34210
34211 if (!args) SWIG_fail;
34212 swig_obj[0] = args;
34213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34214 if (!SWIG_IsOK(res1)) {
34215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34216 }
34217 arg1 = reinterpret_cast< wxWindow * >(argp1);
34218 {
34219 PyThreadState* __tstate = wxPyBeginAllowThreads();
34220 result = (bool)((wxWindow const *)arg1)->HasCapture();
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34226 }
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34234 PyObject *resultobj = 0;
34235 wxWindow *arg1 = (wxWindow *) 0 ;
34236 bool arg2 = (bool) true ;
34237 wxRect *arg3 = (wxRect *) NULL ;
34238 void *argp1 = 0 ;
34239 int res1 = 0 ;
34240 bool val2 ;
34241 int ecode2 = 0 ;
34242 void *argp3 = 0 ;
34243 int res3 = 0 ;
34244 PyObject * obj0 = 0 ;
34245 PyObject * obj1 = 0 ;
34246 PyObject * obj2 = 0 ;
34247 char * kwnames[] = {
34248 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34249 };
34250
34251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34253 if (!SWIG_IsOK(res1)) {
34254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34255 }
34256 arg1 = reinterpret_cast< wxWindow * >(argp1);
34257 if (obj1) {
34258 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34259 if (!SWIG_IsOK(ecode2)) {
34260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34261 }
34262 arg2 = static_cast< bool >(val2);
34263 }
34264 if (obj2) {
34265 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34266 if (!SWIG_IsOK(res3)) {
34267 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34268 }
34269 arg3 = reinterpret_cast< wxRect * >(argp3);
34270 }
34271 {
34272 PyThreadState* __tstate = wxPyBeginAllowThreads();
34273 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34274 wxPyEndAllowThreads(__tstate);
34275 if (PyErr_Occurred()) SWIG_fail;
34276 }
34277 resultobj = SWIG_Py_Void();
34278 return resultobj;
34279 fail:
34280 return NULL;
34281 }
34282
34283
34284 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34285 PyObject *resultobj = 0;
34286 wxWindow *arg1 = (wxWindow *) 0 ;
34287 wxRect *arg2 = 0 ;
34288 bool arg3 = (bool) true ;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 wxRect temp2 ;
34292 bool val3 ;
34293 int ecode3 = 0 ;
34294 PyObject * obj0 = 0 ;
34295 PyObject * obj1 = 0 ;
34296 PyObject * obj2 = 0 ;
34297 char * kwnames[] = {
34298 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34299 };
34300
34301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34303 if (!SWIG_IsOK(res1)) {
34304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34305 }
34306 arg1 = reinterpret_cast< wxWindow * >(argp1);
34307 {
34308 arg2 = &temp2;
34309 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34310 }
34311 if (obj2) {
34312 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34313 if (!SWIG_IsOK(ecode3)) {
34314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34315 }
34316 arg3 = static_cast< bool >(val3);
34317 }
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 resultobj = SWIG_Py_Void();
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34332 PyObject *resultobj = 0;
34333 wxWindow *arg1 = (wxWindow *) 0 ;
34334 void *argp1 = 0 ;
34335 int res1 = 0 ;
34336 PyObject *swig_obj[1] ;
34337
34338 if (!args) SWIG_fail;
34339 swig_obj[0] = args;
34340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34341 if (!SWIG_IsOK(res1)) {
34342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34343 }
34344 arg1 = reinterpret_cast< wxWindow * >(argp1);
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 (arg1)->Update();
34348 wxPyEndAllowThreads(__tstate);
34349 if (PyErr_Occurred()) SWIG_fail;
34350 }
34351 resultobj = SWIG_Py_Void();
34352 return resultobj;
34353 fail:
34354 return NULL;
34355 }
34356
34357
34358 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34359 PyObject *resultobj = 0;
34360 wxWindow *arg1 = (wxWindow *) 0 ;
34361 void *argp1 = 0 ;
34362 int res1 = 0 ;
34363 PyObject *swig_obj[1] ;
34364
34365 if (!args) SWIG_fail;
34366 swig_obj[0] = args;
34367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34368 if (!SWIG_IsOK(res1)) {
34369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34370 }
34371 arg1 = reinterpret_cast< wxWindow * >(argp1);
34372 {
34373 PyThreadState* __tstate = wxPyBeginAllowThreads();
34374 (arg1)->ClearBackground();
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_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34386 PyObject *resultobj = 0;
34387 wxWindow *arg1 = (wxWindow *) 0 ;
34388 void *argp1 = 0 ;
34389 int res1 = 0 ;
34390 PyObject *swig_obj[1] ;
34391
34392 if (!args) SWIG_fail;
34393 swig_obj[0] = args;
34394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34395 if (!SWIG_IsOK(res1)) {
34396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34397 }
34398 arg1 = reinterpret_cast< wxWindow * >(argp1);
34399 {
34400 PyThreadState* __tstate = wxPyBeginAllowThreads();
34401 (arg1)->Freeze();
34402 wxPyEndAllowThreads(__tstate);
34403 if (PyErr_Occurred()) SWIG_fail;
34404 }
34405 resultobj = SWIG_Py_Void();
34406 return resultobj;
34407 fail:
34408 return NULL;
34409 }
34410
34411
34412 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34413 PyObject *resultobj = 0;
34414 wxWindow *arg1 = (wxWindow *) 0 ;
34415 void *argp1 = 0 ;
34416 int res1 = 0 ;
34417 PyObject *swig_obj[1] ;
34418
34419 if (!args) SWIG_fail;
34420 swig_obj[0] = args;
34421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34422 if (!SWIG_IsOK(res1)) {
34423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34424 }
34425 arg1 = reinterpret_cast< wxWindow * >(argp1);
34426 {
34427 PyThreadState* __tstate = wxPyBeginAllowThreads();
34428 (arg1)->Thaw();
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 resultobj = SWIG_Py_Void();
34433 return resultobj;
34434 fail:
34435 return NULL;
34436 }
34437
34438
34439 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34440 PyObject *resultobj = 0;
34441 wxWindow *arg1 = (wxWindow *) 0 ;
34442 wxDC *arg2 = 0 ;
34443 void *argp1 = 0 ;
34444 int res1 = 0 ;
34445 void *argp2 = 0 ;
34446 int res2 = 0 ;
34447 PyObject * obj0 = 0 ;
34448 PyObject * obj1 = 0 ;
34449 char * kwnames[] = {
34450 (char *) "self",(char *) "dc", NULL
34451 };
34452
34453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34455 if (!SWIG_IsOK(res1)) {
34456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34457 }
34458 arg1 = reinterpret_cast< wxWindow * >(argp1);
34459 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34460 if (!SWIG_IsOK(res2)) {
34461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34462 }
34463 if (!argp2) {
34464 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34465 }
34466 arg2 = reinterpret_cast< wxDC * >(argp2);
34467 {
34468 PyThreadState* __tstate = wxPyBeginAllowThreads();
34469 (arg1)->PrepareDC(*arg2);
34470 wxPyEndAllowThreads(__tstate);
34471 if (PyErr_Occurred()) SWIG_fail;
34472 }
34473 resultobj = SWIG_Py_Void();
34474 return resultobj;
34475 fail:
34476 return NULL;
34477 }
34478
34479
34480 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34481 PyObject *resultobj = 0;
34482 wxWindow *arg1 = (wxWindow *) 0 ;
34483 wxRegion *result = 0 ;
34484 void *argp1 = 0 ;
34485 int res1 = 0 ;
34486 PyObject *swig_obj[1] ;
34487
34488 if (!args) SWIG_fail;
34489 swig_obj[0] = args;
34490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34493 }
34494 arg1 = reinterpret_cast< wxWindow * >(argp1);
34495 {
34496 PyThreadState* __tstate = wxPyBeginAllowThreads();
34497 {
34498 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34499 result = (wxRegion *) &_result_ref;
34500 }
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34512 PyObject *resultobj = 0;
34513 wxWindow *arg1 = (wxWindow *) 0 ;
34514 wxRect result;
34515 void *argp1 = 0 ;
34516 int res1 = 0 ;
34517 PyObject *swig_obj[1] ;
34518
34519 if (!args) SWIG_fail;
34520 swig_obj[0] = args;
34521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34522 if (!SWIG_IsOK(res1)) {
34523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34524 }
34525 arg1 = reinterpret_cast< wxWindow * >(argp1);
34526 {
34527 PyThreadState* __tstate = wxPyBeginAllowThreads();
34528 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34529 wxPyEndAllowThreads(__tstate);
34530 if (PyErr_Occurred()) SWIG_fail;
34531 }
34532 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34533 return resultobj;
34534 fail:
34535 return NULL;
34536 }
34537
34538
34539 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34540 PyObject *resultobj = 0;
34541 wxWindow *arg1 = (wxWindow *) 0 ;
34542 int arg2 ;
34543 int arg3 ;
34544 int arg4 = (int) 1 ;
34545 int arg5 = (int) 1 ;
34546 bool result;
34547 void *argp1 = 0 ;
34548 int res1 = 0 ;
34549 int val2 ;
34550 int ecode2 = 0 ;
34551 int val3 ;
34552 int ecode3 = 0 ;
34553 int val4 ;
34554 int ecode4 = 0 ;
34555 int val5 ;
34556 int ecode5 = 0 ;
34557 PyObject * obj0 = 0 ;
34558 PyObject * obj1 = 0 ;
34559 PyObject * obj2 = 0 ;
34560 PyObject * obj3 = 0 ;
34561 PyObject * obj4 = 0 ;
34562 char * kwnames[] = {
34563 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34564 };
34565
34566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34568 if (!SWIG_IsOK(res1)) {
34569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34570 }
34571 arg1 = reinterpret_cast< wxWindow * >(argp1);
34572 ecode2 = SWIG_AsVal_int(obj1, &val2);
34573 if (!SWIG_IsOK(ecode2)) {
34574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34575 }
34576 arg2 = static_cast< int >(val2);
34577 ecode3 = SWIG_AsVal_int(obj2, &val3);
34578 if (!SWIG_IsOK(ecode3)) {
34579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34580 }
34581 arg3 = static_cast< int >(val3);
34582 if (obj3) {
34583 ecode4 = SWIG_AsVal_int(obj3, &val4);
34584 if (!SWIG_IsOK(ecode4)) {
34585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34586 }
34587 arg4 = static_cast< int >(val4);
34588 }
34589 if (obj4) {
34590 ecode5 = SWIG_AsVal_int(obj4, &val5);
34591 if (!SWIG_IsOK(ecode5)) {
34592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34593 }
34594 arg5 = static_cast< int >(val5);
34595 }
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 {
34603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34604 }
34605 return resultobj;
34606 fail:
34607 return NULL;
34608 }
34609
34610
34611 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj = 0;
34613 wxWindow *arg1 = (wxWindow *) 0 ;
34614 wxPoint *arg2 = 0 ;
34615 bool result;
34616 void *argp1 = 0 ;
34617 int res1 = 0 ;
34618 wxPoint temp2 ;
34619 PyObject * obj0 = 0 ;
34620 PyObject * obj1 = 0 ;
34621 char * kwnames[] = {
34622 (char *) "self",(char *) "pt", NULL
34623 };
34624
34625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34627 if (!SWIG_IsOK(res1)) {
34628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34629 }
34630 arg1 = reinterpret_cast< wxWindow * >(argp1);
34631 {
34632 arg2 = &temp2;
34633 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34634 }
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 {
34642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34643 }
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 wxRect *arg2 = 0 ;
34654 bool result;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 wxRect temp2 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 char * kwnames[] = {
34661 (char *) "self",(char *) "rect", NULL
34662 };
34663
34664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34668 }
34669 arg1 = reinterpret_cast< wxWindow * >(argp1);
34670 {
34671 arg2 = &temp2;
34672 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34673 }
34674 {
34675 PyThreadState* __tstate = wxPyBeginAllowThreads();
34676 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 {
34681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34682 }
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34690 PyObject *resultobj = 0;
34691 wxWindow *arg1 = (wxWindow *) 0 ;
34692 SwigValueWrapper<wxVisualAttributes > result;
34693 void *argp1 = 0 ;
34694 int res1 = 0 ;
34695 PyObject *swig_obj[1] ;
34696
34697 if (!args) SWIG_fail;
34698 swig_obj[0] = args;
34699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34700 if (!SWIG_IsOK(res1)) {
34701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34702 }
34703 arg1 = reinterpret_cast< wxWindow * >(argp1);
34704 {
34705 PyThreadState* __tstate = wxPyBeginAllowThreads();
34706 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34711 return resultobj;
34712 fail:
34713 return NULL;
34714 }
34715
34716
34717 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34718 PyObject *resultobj = 0;
34719 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34720 SwigValueWrapper<wxVisualAttributes > result;
34721 int val1 ;
34722 int ecode1 = 0 ;
34723 PyObject * obj0 = 0 ;
34724 char * kwnames[] = {
34725 (char *) "variant", NULL
34726 };
34727
34728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34729 if (obj0) {
34730 ecode1 = SWIG_AsVal_int(obj0, &val1);
34731 if (!SWIG_IsOK(ecode1)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34733 }
34734 arg1 = static_cast< wxWindowVariant >(val1);
34735 }
34736 {
34737 if (!wxPyCheckForApp()) SWIG_fail;
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 result = wxWindow::GetClassDefaultAttributes(arg1);
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34744 return resultobj;
34745 fail:
34746 return NULL;
34747 }
34748
34749
34750 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34751 PyObject *resultobj = 0;
34752 wxWindow *arg1 = (wxWindow *) 0 ;
34753 wxColour *arg2 = 0 ;
34754 bool result;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 wxColour temp2 ;
34758 PyObject * obj0 = 0 ;
34759 PyObject * obj1 = 0 ;
34760 char * kwnames[] = {
34761 (char *) "self",(char *) "colour", NULL
34762 };
34763
34764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34766 if (!SWIG_IsOK(res1)) {
34767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34768 }
34769 arg1 = reinterpret_cast< wxWindow * >(argp1);
34770 {
34771 arg2 = &temp2;
34772 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34773 }
34774 {
34775 PyThreadState* __tstate = wxPyBeginAllowThreads();
34776 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34777 wxPyEndAllowThreads(__tstate);
34778 if (PyErr_Occurred()) SWIG_fail;
34779 }
34780 {
34781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34782 }
34783 return resultobj;
34784 fail:
34785 return NULL;
34786 }
34787
34788
34789 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34790 PyObject *resultobj = 0;
34791 wxWindow *arg1 = (wxWindow *) 0 ;
34792 wxColour *arg2 = 0 ;
34793 void *argp1 = 0 ;
34794 int res1 = 0 ;
34795 wxColour temp2 ;
34796 PyObject * obj0 = 0 ;
34797 PyObject * obj1 = 0 ;
34798 char * kwnames[] = {
34799 (char *) "self",(char *) "colour", NULL
34800 };
34801
34802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34804 if (!SWIG_IsOK(res1)) {
34805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34806 }
34807 arg1 = reinterpret_cast< wxWindow * >(argp1);
34808 {
34809 arg2 = &temp2;
34810 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34811 }
34812 {
34813 PyThreadState* __tstate = wxPyBeginAllowThreads();
34814 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 resultobj = SWIG_Py_Void();
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj = 0;
34827 wxWindow *arg1 = (wxWindow *) 0 ;
34828 wxColour *arg2 = 0 ;
34829 bool result;
34830 void *argp1 = 0 ;
34831 int res1 = 0 ;
34832 wxColour temp2 ;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 char * kwnames[] = {
34836 (char *) "self",(char *) "colour", NULL
34837 };
34838
34839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34841 if (!SWIG_IsOK(res1)) {
34842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34843 }
34844 arg1 = reinterpret_cast< wxWindow * >(argp1);
34845 {
34846 arg2 = &temp2;
34847 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34848 }
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34852 wxPyEndAllowThreads(__tstate);
34853 if (PyErr_Occurred()) SWIG_fail;
34854 }
34855 {
34856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34857 }
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34865 PyObject *resultobj = 0;
34866 wxWindow *arg1 = (wxWindow *) 0 ;
34867 wxColour *arg2 = 0 ;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 wxColour temp2 ;
34871 PyObject * obj0 = 0 ;
34872 PyObject * obj1 = 0 ;
34873 char * kwnames[] = {
34874 (char *) "self",(char *) "colour", NULL
34875 };
34876
34877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34879 if (!SWIG_IsOK(res1)) {
34880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34881 }
34882 arg1 = reinterpret_cast< wxWindow * >(argp1);
34883 {
34884 arg2 = &temp2;
34885 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34886 }
34887 {
34888 PyThreadState* __tstate = wxPyBeginAllowThreads();
34889 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34890 wxPyEndAllowThreads(__tstate);
34891 if (PyErr_Occurred()) SWIG_fail;
34892 }
34893 resultobj = SWIG_Py_Void();
34894 return resultobj;
34895 fail:
34896 return NULL;
34897 }
34898
34899
34900 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34901 PyObject *resultobj = 0;
34902 wxWindow *arg1 = (wxWindow *) 0 ;
34903 wxColour result;
34904 void *argp1 = 0 ;
34905 int res1 = 0 ;
34906 PyObject *swig_obj[1] ;
34907
34908 if (!args) SWIG_fail;
34909 swig_obj[0] = args;
34910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34911 if (!SWIG_IsOK(res1)) {
34912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34913 }
34914 arg1 = reinterpret_cast< wxWindow * >(argp1);
34915 {
34916 PyThreadState* __tstate = wxPyBeginAllowThreads();
34917 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34922 return resultobj;
34923 fail:
34924 return NULL;
34925 }
34926
34927
34928 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34929 PyObject *resultobj = 0;
34930 wxWindow *arg1 = (wxWindow *) 0 ;
34931 wxColour result;
34932 void *argp1 = 0 ;
34933 int res1 = 0 ;
34934 PyObject *swig_obj[1] ;
34935
34936 if (!args) SWIG_fail;
34937 swig_obj[0] = args;
34938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 result = ((wxWindow const *)arg1)->GetForegroundColour();
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34957 PyObject *resultobj = 0;
34958 wxWindow *arg1 = (wxWindow *) 0 ;
34959 bool result;
34960 void *argp1 = 0 ;
34961 int res1 = 0 ;
34962 PyObject *swig_obj[1] ;
34963
34964 if (!args) SWIG_fail;
34965 swig_obj[0] = args;
34966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34967 if (!SWIG_IsOK(res1)) {
34968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34969 }
34970 arg1 = reinterpret_cast< wxWindow * >(argp1);
34971 {
34972 PyThreadState* __tstate = wxPyBeginAllowThreads();
34973 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 {
34978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34979 }
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34987 PyObject *resultobj = 0;
34988 wxWindow *arg1 = (wxWindow *) 0 ;
34989 bool result;
34990 void *argp1 = 0 ;
34991 int res1 = 0 ;
34992 PyObject *swig_obj[1] ;
34993
34994 if (!args) SWIG_fail;
34995 swig_obj[0] = args;
34996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34997 if (!SWIG_IsOK(res1)) {
34998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34999 }
35000 arg1 = reinterpret_cast< wxWindow * >(argp1);
35001 {
35002 PyThreadState* __tstate = wxPyBeginAllowThreads();
35003 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35004 wxPyEndAllowThreads(__tstate);
35005 if (PyErr_Occurred()) SWIG_fail;
35006 }
35007 {
35008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35009 }
35010 return resultobj;
35011 fail:
35012 return NULL;
35013 }
35014
35015
35016 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35017 PyObject *resultobj = 0;
35018 wxWindow *arg1 = (wxWindow *) 0 ;
35019 wxBackgroundStyle arg2 ;
35020 bool result;
35021 void *argp1 = 0 ;
35022 int res1 = 0 ;
35023 int val2 ;
35024 int ecode2 = 0 ;
35025 PyObject * obj0 = 0 ;
35026 PyObject * obj1 = 0 ;
35027 char * kwnames[] = {
35028 (char *) "self",(char *) "style", NULL
35029 };
35030
35031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35033 if (!SWIG_IsOK(res1)) {
35034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35035 }
35036 arg1 = reinterpret_cast< wxWindow * >(argp1);
35037 ecode2 = SWIG_AsVal_int(obj1, &val2);
35038 if (!SWIG_IsOK(ecode2)) {
35039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35040 }
35041 arg2 = static_cast< wxBackgroundStyle >(val2);
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 {
35049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35050 }
35051 return resultobj;
35052 fail:
35053 return NULL;
35054 }
35055
35056
35057 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35058 PyObject *resultobj = 0;
35059 wxWindow *arg1 = (wxWindow *) 0 ;
35060 wxBackgroundStyle result;
35061 void *argp1 = 0 ;
35062 int res1 = 0 ;
35063 PyObject *swig_obj[1] ;
35064
35065 if (!args) SWIG_fail;
35066 swig_obj[0] = args;
35067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35068 if (!SWIG_IsOK(res1)) {
35069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35070 }
35071 arg1 = reinterpret_cast< wxWindow * >(argp1);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_From_int(static_cast< int >(result));
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 bool result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 PyObject *swig_obj[1] ;
35092
35093 if (!args) SWIG_fail;
35094 swig_obj[0] = args;
35095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35096 if (!SWIG_IsOK(res1)) {
35097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35098 }
35099 arg1 = reinterpret_cast< wxWindow * >(argp1);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (bool)(arg1)->HasTransparentBackground();
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxCursor *arg2 = 0 ;
35119 bool result;
35120 void *argp1 = 0 ;
35121 int res1 = 0 ;
35122 void *argp2 = 0 ;
35123 int res2 = 0 ;
35124 PyObject * obj0 = 0 ;
35125 PyObject * obj1 = 0 ;
35126 char * kwnames[] = {
35127 (char *) "self",(char *) "cursor", NULL
35128 };
35129
35130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35134 }
35135 arg1 = reinterpret_cast< wxWindow * >(argp1);
35136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35137 if (!SWIG_IsOK(res2)) {
35138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35139 }
35140 if (!argp2) {
35141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35142 }
35143 arg2 = reinterpret_cast< wxCursor * >(argp2);
35144 {
35145 PyThreadState* __tstate = wxPyBeginAllowThreads();
35146 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35147 wxPyEndAllowThreads(__tstate);
35148 if (PyErr_Occurred()) SWIG_fail;
35149 }
35150 {
35151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35152 }
35153 return resultobj;
35154 fail:
35155 return NULL;
35156 }
35157
35158
35159 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35160 PyObject *resultobj = 0;
35161 wxWindow *arg1 = (wxWindow *) 0 ;
35162 wxCursor result;
35163 void *argp1 = 0 ;
35164 int res1 = 0 ;
35165 PyObject *swig_obj[1] ;
35166
35167 if (!args) SWIG_fail;
35168 swig_obj[0] = args;
35169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35170 if (!SWIG_IsOK(res1)) {
35171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35172 }
35173 arg1 = reinterpret_cast< wxWindow * >(argp1);
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (arg1)->GetCursor();
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 wxFont *arg2 = 0 ;
35191 bool result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 void *argp2 = 0 ;
35195 int res2 = 0 ;
35196 PyObject * obj0 = 0 ;
35197 PyObject * obj1 = 0 ;
35198 char * kwnames[] = {
35199 (char *) "self",(char *) "font", NULL
35200 };
35201
35202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35204 if (!SWIG_IsOK(res1)) {
35205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35206 }
35207 arg1 = reinterpret_cast< wxWindow * >(argp1);
35208 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35209 if (!SWIG_IsOK(res2)) {
35210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35211 }
35212 if (!argp2) {
35213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35214 }
35215 arg2 = reinterpret_cast< wxFont * >(argp2);
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35219 wxPyEndAllowThreads(__tstate);
35220 if (PyErr_Occurred()) SWIG_fail;
35221 }
35222 {
35223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35224 }
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 wxFont *arg2 = 0 ;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 void *argp2 = 0 ;
35238 int res2 = 0 ;
35239 PyObject * obj0 = 0 ;
35240 PyObject * obj1 = 0 ;
35241 char * kwnames[] = {
35242 (char *) "self",(char *) "font", NULL
35243 };
35244
35245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35247 if (!SWIG_IsOK(res1)) {
35248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35249 }
35250 arg1 = reinterpret_cast< wxWindow * >(argp1);
35251 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35252 if (!SWIG_IsOK(res2)) {
35253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35254 }
35255 if (!argp2) {
35256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35257 }
35258 arg2 = reinterpret_cast< wxFont * >(argp2);
35259 {
35260 PyThreadState* __tstate = wxPyBeginAllowThreads();
35261 (arg1)->SetOwnFont((wxFont const &)*arg2);
35262 wxPyEndAllowThreads(__tstate);
35263 if (PyErr_Occurred()) SWIG_fail;
35264 }
35265 resultobj = SWIG_Py_Void();
35266 return resultobj;
35267 fail:
35268 return NULL;
35269 }
35270
35271
35272 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35273 PyObject *resultobj = 0;
35274 wxWindow *arg1 = (wxWindow *) 0 ;
35275 wxFont result;
35276 void *argp1 = 0 ;
35277 int res1 = 0 ;
35278 PyObject *swig_obj[1] ;
35279
35280 if (!args) SWIG_fail;
35281 swig_obj[0] = args;
35282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35283 if (!SWIG_IsOK(res1)) {
35284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35285 }
35286 arg1 = reinterpret_cast< wxWindow * >(argp1);
35287 {
35288 PyThreadState* __tstate = wxPyBeginAllowThreads();
35289 result = (arg1)->GetFont();
35290 wxPyEndAllowThreads(__tstate);
35291 if (PyErr_Occurred()) SWIG_fail;
35292 }
35293 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35294 return resultobj;
35295 fail:
35296 return NULL;
35297 }
35298
35299
35300 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35301 PyObject *resultobj = 0;
35302 wxWindow *arg1 = (wxWindow *) 0 ;
35303 wxCaret *arg2 = (wxCaret *) 0 ;
35304 void *argp1 = 0 ;
35305 int res1 = 0 ;
35306 int res2 = 0 ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 char * kwnames[] = {
35310 (char *) "self",(char *) "caret", NULL
35311 };
35312
35313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35317 }
35318 arg1 = reinterpret_cast< wxWindow * >(argp1);
35319 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35320 if (!SWIG_IsOK(res2)) {
35321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35322 }
35323 {
35324 PyThreadState* __tstate = wxPyBeginAllowThreads();
35325 (arg1)->SetCaret(arg2);
35326 wxPyEndAllowThreads(__tstate);
35327 if (PyErr_Occurred()) SWIG_fail;
35328 }
35329 resultobj = SWIG_Py_Void();
35330 return resultobj;
35331 fail:
35332 return NULL;
35333 }
35334
35335
35336 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35337 PyObject *resultobj = 0;
35338 wxWindow *arg1 = (wxWindow *) 0 ;
35339 wxCaret *result = 0 ;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 PyObject *swig_obj[1] ;
35343
35344 if (!args) SWIG_fail;
35345 swig_obj[0] = args;
35346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35347 if (!SWIG_IsOK(res1)) {
35348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35349 }
35350 arg1 = reinterpret_cast< wxWindow * >(argp1);
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35358 return resultobj;
35359 fail:
35360 return NULL;
35361 }
35362
35363
35364 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35365 PyObject *resultobj = 0;
35366 wxWindow *arg1 = (wxWindow *) 0 ;
35367 int result;
35368 void *argp1 = 0 ;
35369 int res1 = 0 ;
35370 PyObject *swig_obj[1] ;
35371
35372 if (!args) SWIG_fail;
35373 swig_obj[0] = args;
35374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35375 if (!SWIG_IsOK(res1)) {
35376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35377 }
35378 arg1 = reinterpret_cast< wxWindow * >(argp1);
35379 {
35380 PyThreadState* __tstate = wxPyBeginAllowThreads();
35381 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35382 wxPyEndAllowThreads(__tstate);
35383 if (PyErr_Occurred()) SWIG_fail;
35384 }
35385 resultobj = SWIG_From_int(static_cast< int >(result));
35386 return resultobj;
35387 fail:
35388 return NULL;
35389 }
35390
35391
35392 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35393 PyObject *resultobj = 0;
35394 wxWindow *arg1 = (wxWindow *) 0 ;
35395 int result;
35396 void *argp1 = 0 ;
35397 int res1 = 0 ;
35398 PyObject *swig_obj[1] ;
35399
35400 if (!args) SWIG_fail;
35401 swig_obj[0] = args;
35402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35405 }
35406 arg1 = reinterpret_cast< wxWindow * >(argp1);
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 resultobj = SWIG_From_int(static_cast< int >(result));
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 wxString *arg2 = 0 ;
35424 int *arg3 = (int *) 0 ;
35425 int *arg4 = (int *) 0 ;
35426 void *argp1 = 0 ;
35427 int res1 = 0 ;
35428 bool temp2 = false ;
35429 int temp3 ;
35430 int res3 = SWIG_TMPOBJ ;
35431 int temp4 ;
35432 int res4 = SWIG_TMPOBJ ;
35433 PyObject * obj0 = 0 ;
35434 PyObject * obj1 = 0 ;
35435 char * kwnames[] = {
35436 (char *) "self",(char *) "string", NULL
35437 };
35438
35439 arg3 = &temp3;
35440 arg4 = &temp4;
35441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 arg2 = wxString_in_helper(obj1);
35449 if (arg2 == NULL) SWIG_fail;
35450 temp2 = true;
35451 }
35452 {
35453 PyThreadState* __tstate = wxPyBeginAllowThreads();
35454 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35455 wxPyEndAllowThreads(__tstate);
35456 if (PyErr_Occurred()) SWIG_fail;
35457 }
35458 resultobj = SWIG_Py_Void();
35459 if (SWIG_IsTmpObj(res3)) {
35460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35461 } else {
35462 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35464 }
35465 if (SWIG_IsTmpObj(res4)) {
35466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35467 } else {
35468 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35470 }
35471 {
35472 if (temp2)
35473 delete arg2;
35474 }
35475 return resultobj;
35476 fail:
35477 {
35478 if (temp2)
35479 delete arg2;
35480 }
35481 return NULL;
35482 }
35483
35484
35485 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35486 PyObject *resultobj = 0;
35487 wxWindow *arg1 = (wxWindow *) 0 ;
35488 wxString *arg2 = 0 ;
35489 int *arg3 = (int *) 0 ;
35490 int *arg4 = (int *) 0 ;
35491 int *arg5 = (int *) 0 ;
35492 int *arg6 = (int *) 0 ;
35493 wxFont *arg7 = (wxFont *) NULL ;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 bool temp2 = false ;
35497 int temp3 ;
35498 int res3 = SWIG_TMPOBJ ;
35499 int temp4 ;
35500 int res4 = SWIG_TMPOBJ ;
35501 int temp5 ;
35502 int res5 = SWIG_TMPOBJ ;
35503 int temp6 ;
35504 int res6 = SWIG_TMPOBJ ;
35505 void *argp7 = 0 ;
35506 int res7 = 0 ;
35507 PyObject * obj0 = 0 ;
35508 PyObject * obj1 = 0 ;
35509 PyObject * obj2 = 0 ;
35510 char * kwnames[] = {
35511 (char *) "self",(char *) "string",(char *) "font", NULL
35512 };
35513
35514 arg3 = &temp3;
35515 arg4 = &temp4;
35516 arg5 = &temp5;
35517 arg6 = &temp6;
35518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35520 if (!SWIG_IsOK(res1)) {
35521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35522 }
35523 arg1 = reinterpret_cast< wxWindow * >(argp1);
35524 {
35525 arg2 = wxString_in_helper(obj1);
35526 if (arg2 == NULL) SWIG_fail;
35527 temp2 = true;
35528 }
35529 if (obj2) {
35530 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35531 if (!SWIG_IsOK(res7)) {
35532 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35533 }
35534 arg7 = reinterpret_cast< wxFont * >(argp7);
35535 }
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 resultobj = SWIG_Py_Void();
35543 if (SWIG_IsTmpObj(res3)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35548 }
35549 if (SWIG_IsTmpObj(res4)) {
35550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35551 } else {
35552 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35554 }
35555 if (SWIG_IsTmpObj(res5)) {
35556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35557 } else {
35558 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35560 }
35561 if (SWIG_IsTmpObj(res6)) {
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35563 } else {
35564 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35566 }
35567 {
35568 if (temp2)
35569 delete arg2;
35570 }
35571 return resultobj;
35572 fail:
35573 {
35574 if (temp2)
35575 delete arg2;
35576 }
35577 return NULL;
35578 }
35579
35580
35581 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35582 PyObject *resultobj = 0;
35583 wxWindow *arg1 = (wxWindow *) 0 ;
35584 int *arg2 = (int *) 0 ;
35585 int *arg3 = (int *) 0 ;
35586 void *argp1 = 0 ;
35587 int res1 = 0 ;
35588 int temp2 ;
35589 int res2 = 0 ;
35590 int temp3 ;
35591 int res3 = 0 ;
35592 PyObject * obj0 = 0 ;
35593 PyObject * obj1 = 0 ;
35594 PyObject * obj2 = 0 ;
35595 char * kwnames[] = {
35596 (char *) "self",(char *) "x",(char *) "y", NULL
35597 };
35598
35599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35601 if (!SWIG_IsOK(res1)) {
35602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35603 }
35604 arg1 = reinterpret_cast< wxWindow * >(argp1);
35605 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35606 int val;
35607 int ecode = SWIG_AsVal_int(obj1, &val);
35608 if (!SWIG_IsOK(ecode)) {
35609 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35610 }
35611 temp2 = static_cast< int >(val);
35612 arg2 = &temp2;
35613 res2 = SWIG_AddTmpMask(ecode);
35614 }
35615 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35616 int val;
35617 int ecode = SWIG_AsVal_int(obj2, &val);
35618 if (!SWIG_IsOK(ecode)) {
35619 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35620 }
35621 temp3 = static_cast< int >(val);
35622 arg3 = &temp3;
35623 res3 = SWIG_AddTmpMask(ecode);
35624 }
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 resultobj = SWIG_Py_Void();
35632 if (SWIG_IsTmpObj(res2)) {
35633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35634 } else {
35635 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35637 }
35638 if (SWIG_IsTmpObj(res3)) {
35639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35640 } else {
35641 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35642 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35643 }
35644 return resultobj;
35645 fail:
35646 return NULL;
35647 }
35648
35649
35650 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35651 PyObject *resultobj = 0;
35652 wxWindow *arg1 = (wxWindow *) 0 ;
35653 int *arg2 = (int *) 0 ;
35654 int *arg3 = (int *) 0 ;
35655 void *argp1 = 0 ;
35656 int res1 = 0 ;
35657 int temp2 ;
35658 int res2 = 0 ;
35659 int temp3 ;
35660 int res3 = 0 ;
35661 PyObject * obj0 = 0 ;
35662 PyObject * obj1 = 0 ;
35663 PyObject * obj2 = 0 ;
35664 char * kwnames[] = {
35665 (char *) "self",(char *) "x",(char *) "y", NULL
35666 };
35667
35668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35672 }
35673 arg1 = reinterpret_cast< wxWindow * >(argp1);
35674 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35675 int val;
35676 int ecode = SWIG_AsVal_int(obj1, &val);
35677 if (!SWIG_IsOK(ecode)) {
35678 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35679 }
35680 temp2 = static_cast< int >(val);
35681 arg2 = &temp2;
35682 res2 = SWIG_AddTmpMask(ecode);
35683 }
35684 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35685 int val;
35686 int ecode = SWIG_AsVal_int(obj2, &val);
35687 if (!SWIG_IsOK(ecode)) {
35688 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35689 }
35690 temp3 = static_cast< int >(val);
35691 arg3 = &temp3;
35692 res3 = SWIG_AddTmpMask(ecode);
35693 }
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 resultobj = SWIG_Py_Void();
35701 if (SWIG_IsTmpObj(res2)) {
35702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35703 } else {
35704 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35706 }
35707 if (SWIG_IsTmpObj(res3)) {
35708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35709 } else {
35710 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35711 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35712 }
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj = 0;
35721 wxWindow *arg1 = (wxWindow *) 0 ;
35722 wxPoint *arg2 = 0 ;
35723 wxPoint result;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 wxPoint temp2 ;
35727 PyObject * obj0 = 0 ;
35728 PyObject * obj1 = 0 ;
35729 char * kwnames[] = {
35730 (char *) "self",(char *) "pt", NULL
35731 };
35732
35733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35735 if (!SWIG_IsOK(res1)) {
35736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35737 }
35738 arg1 = reinterpret_cast< wxWindow * >(argp1);
35739 {
35740 arg2 = &temp2;
35741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35742 }
35743 {
35744 PyThreadState* __tstate = wxPyBeginAllowThreads();
35745 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35746 wxPyEndAllowThreads(__tstate);
35747 if (PyErr_Occurred()) SWIG_fail;
35748 }
35749 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35750 return resultobj;
35751 fail:
35752 return NULL;
35753 }
35754
35755
35756 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35757 PyObject *resultobj = 0;
35758 wxWindow *arg1 = (wxWindow *) 0 ;
35759 wxPoint *arg2 = 0 ;
35760 wxPoint result;
35761 void *argp1 = 0 ;
35762 int res1 = 0 ;
35763 wxPoint temp2 ;
35764 PyObject * obj0 = 0 ;
35765 PyObject * obj1 = 0 ;
35766 char * kwnames[] = {
35767 (char *) "self",(char *) "pt", NULL
35768 };
35769
35770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35772 if (!SWIG_IsOK(res1)) {
35773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35774 }
35775 arg1 = reinterpret_cast< wxWindow * >(argp1);
35776 {
35777 arg2 = &temp2;
35778 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35779 }
35780 {
35781 PyThreadState* __tstate = wxPyBeginAllowThreads();
35782 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35783 wxPyEndAllowThreads(__tstate);
35784 if (PyErr_Occurred()) SWIG_fail;
35785 }
35786 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35787 return resultobj;
35788 fail:
35789 return NULL;
35790 }
35791
35792
35793 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35794 PyObject *resultobj = 0;
35795 wxWindow *arg1 = (wxWindow *) 0 ;
35796 int arg2 ;
35797 int arg3 ;
35798 wxHitTest result;
35799 void *argp1 = 0 ;
35800 int res1 = 0 ;
35801 int val2 ;
35802 int ecode2 = 0 ;
35803 int val3 ;
35804 int ecode3 = 0 ;
35805 PyObject * obj0 = 0 ;
35806 PyObject * obj1 = 0 ;
35807 PyObject * obj2 = 0 ;
35808 char * kwnames[] = {
35809 (char *) "self",(char *) "x",(char *) "y", NULL
35810 };
35811
35812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35814 if (!SWIG_IsOK(res1)) {
35815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35816 }
35817 arg1 = reinterpret_cast< wxWindow * >(argp1);
35818 ecode2 = SWIG_AsVal_int(obj1, &val2);
35819 if (!SWIG_IsOK(ecode2)) {
35820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35821 }
35822 arg2 = static_cast< int >(val2);
35823 ecode3 = SWIG_AsVal_int(obj2, &val3);
35824 if (!SWIG_IsOK(ecode3)) {
35825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35826 }
35827 arg3 = static_cast< int >(val3);
35828 {
35829 PyThreadState* __tstate = wxPyBeginAllowThreads();
35830 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35831 wxPyEndAllowThreads(__tstate);
35832 if (PyErr_Occurred()) SWIG_fail;
35833 }
35834 resultobj = SWIG_From_int(static_cast< int >(result));
35835 return resultobj;
35836 fail:
35837 return NULL;
35838 }
35839
35840
35841 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35842 PyObject *resultobj = 0;
35843 wxWindow *arg1 = (wxWindow *) 0 ;
35844 wxPoint *arg2 = 0 ;
35845 wxHitTest result;
35846 void *argp1 = 0 ;
35847 int res1 = 0 ;
35848 wxPoint temp2 ;
35849 PyObject * obj0 = 0 ;
35850 PyObject * obj1 = 0 ;
35851 char * kwnames[] = {
35852 (char *) "self",(char *) "pt", NULL
35853 };
35854
35855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 {
35862 arg2 = &temp2;
35863 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35864 }
35865 {
35866 PyThreadState* __tstate = wxPyBeginAllowThreads();
35867 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35868 wxPyEndAllowThreads(__tstate);
35869 if (PyErr_Occurred()) SWIG_fail;
35870 }
35871 resultobj = SWIG_From_int(static_cast< int >(result));
35872 return resultobj;
35873 fail:
35874 return NULL;
35875 }
35876
35877
35878 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35879 PyObject *resultobj = 0;
35880 wxWindow *arg1 = (wxWindow *) 0 ;
35881 long arg2 ;
35882 wxBorder result;
35883 void *argp1 = 0 ;
35884 int res1 = 0 ;
35885 long val2 ;
35886 int ecode2 = 0 ;
35887
35888 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35890 if (!SWIG_IsOK(res1)) {
35891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35892 }
35893 arg1 = reinterpret_cast< wxWindow * >(argp1);
35894 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35895 if (!SWIG_IsOK(ecode2)) {
35896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35897 }
35898 arg2 = static_cast< long >(val2);
35899 {
35900 PyThreadState* __tstate = wxPyBeginAllowThreads();
35901 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35902 wxPyEndAllowThreads(__tstate);
35903 if (PyErr_Occurred()) SWIG_fail;
35904 }
35905 resultobj = SWIG_From_int(static_cast< int >(result));
35906 return resultobj;
35907 fail:
35908 return NULL;
35909 }
35910
35911
35912 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35913 PyObject *resultobj = 0;
35914 wxWindow *arg1 = (wxWindow *) 0 ;
35915 wxBorder result;
35916 void *argp1 = 0 ;
35917 int res1 = 0 ;
35918
35919 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_From_int(static_cast< int >(result));
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35939 int argc;
35940 PyObject *argv[3];
35941
35942 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35943 --argc;
35944 if (argc == 1) {
35945 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35946 }
35947 if (argc == 2) {
35948 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35949 }
35950
35951 fail:
35952 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35958 PyObject *resultobj = 0;
35959 wxWindow *arg1 = (wxWindow *) 0 ;
35960 long arg2 = (long) wxUPDATE_UI_NONE ;
35961 void *argp1 = 0 ;
35962 int res1 = 0 ;
35963 long val2 ;
35964 int ecode2 = 0 ;
35965 PyObject * obj0 = 0 ;
35966 PyObject * obj1 = 0 ;
35967 char * kwnames[] = {
35968 (char *) "self",(char *) "flags", NULL
35969 };
35970
35971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35973 if (!SWIG_IsOK(res1)) {
35974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35975 }
35976 arg1 = reinterpret_cast< wxWindow * >(argp1);
35977 if (obj1) {
35978 ecode2 = SWIG_AsVal_long(obj1, &val2);
35979 if (!SWIG_IsOK(ecode2)) {
35980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35981 }
35982 arg2 = static_cast< long >(val2);
35983 }
35984 {
35985 PyThreadState* __tstate = wxPyBeginAllowThreads();
35986 (arg1)->UpdateWindowUI(arg2);
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 resultobj = SWIG_Py_Void();
35991 return resultobj;
35992 fail:
35993 return NULL;
35994 }
35995
35996
35997 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35998 PyObject *resultobj = 0;
35999 wxWindow *arg1 = (wxWindow *) 0 ;
36000 wxMenu *arg2 = (wxMenu *) 0 ;
36001 int arg3 = (int) -1 ;
36002 int arg4 = (int) -1 ;
36003 bool result;
36004 void *argp1 = 0 ;
36005 int res1 = 0 ;
36006 void *argp2 = 0 ;
36007 int res2 = 0 ;
36008 int val3 ;
36009 int ecode3 = 0 ;
36010 int val4 ;
36011 int ecode4 = 0 ;
36012 PyObject * obj0 = 0 ;
36013 PyObject * obj1 = 0 ;
36014 PyObject * obj2 = 0 ;
36015 PyObject * obj3 = 0 ;
36016 char * kwnames[] = {
36017 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36018 };
36019
36020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36027 if (!SWIG_IsOK(res2)) {
36028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36029 }
36030 arg2 = reinterpret_cast< wxMenu * >(argp2);
36031 if (obj2) {
36032 ecode3 = SWIG_AsVal_int(obj2, &val3);
36033 if (!SWIG_IsOK(ecode3)) {
36034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36035 }
36036 arg3 = static_cast< int >(val3);
36037 }
36038 if (obj3) {
36039 ecode4 = SWIG_AsVal_int(obj3, &val4);
36040 if (!SWIG_IsOK(ecode4)) {
36041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36042 }
36043 arg4 = static_cast< int >(val4);
36044 }
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 {
36052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36053 }
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 wxMenu *arg2 = (wxMenu *) 0 ;
36064 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36065 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36066 bool result;
36067 void *argp1 = 0 ;
36068 int res1 = 0 ;
36069 void *argp2 = 0 ;
36070 int res2 = 0 ;
36071 wxPoint temp3 ;
36072 PyObject * obj0 = 0 ;
36073 PyObject * obj1 = 0 ;
36074 PyObject * obj2 = 0 ;
36075 char * kwnames[] = {
36076 (char *) "self",(char *) "menu",(char *) "pos", NULL
36077 };
36078
36079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36083 }
36084 arg1 = reinterpret_cast< wxWindow * >(argp1);
36085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36086 if (!SWIG_IsOK(res2)) {
36087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36088 }
36089 arg2 = reinterpret_cast< wxMenu * >(argp2);
36090 if (obj2) {
36091 {
36092 arg3 = &temp3;
36093 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36094 }
36095 }
36096 {
36097 PyThreadState* __tstate = wxPyBeginAllowThreads();
36098 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 {
36103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36104 }
36105 return resultobj;
36106 fail:
36107 return NULL;
36108 }
36109
36110
36111 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36112 PyObject *resultobj = 0;
36113 wxWindow *arg1 = (wxWindow *) 0 ;
36114 long result;
36115 void *argp1 = 0 ;
36116 int res1 = 0 ;
36117 PyObject *swig_obj[1] ;
36118
36119 if (!args) SWIG_fail;
36120 swig_obj[0] = args;
36121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36122 if (!SWIG_IsOK(res1)) {
36123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36124 }
36125 arg1 = reinterpret_cast< wxWindow * >(argp1);
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (long)wxWindow_GetHandle(arg1);
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 resultobj = SWIG_From_long(static_cast< long >(result));
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36140 PyObject *resultobj = 0;
36141 wxWindow *arg1 = (wxWindow *) 0 ;
36142 long arg2 ;
36143 void *argp1 = 0 ;
36144 int res1 = 0 ;
36145 long val2 ;
36146 int ecode2 = 0 ;
36147 PyObject * obj0 = 0 ;
36148 PyObject * obj1 = 0 ;
36149 char * kwnames[] = {
36150 (char *) "self",(char *) "handle", NULL
36151 };
36152
36153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36155 if (!SWIG_IsOK(res1)) {
36156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36157 }
36158 arg1 = reinterpret_cast< wxWindow * >(argp1);
36159 ecode2 = SWIG_AsVal_long(obj1, &val2);
36160 if (!SWIG_IsOK(ecode2)) {
36161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36162 }
36163 arg2 = static_cast< long >(val2);
36164 {
36165 PyThreadState* __tstate = wxPyBeginAllowThreads();
36166 wxWindow_AssociateHandle(arg1,arg2);
36167 wxPyEndAllowThreads(__tstate);
36168 if (PyErr_Occurred()) SWIG_fail;
36169 }
36170 resultobj = SWIG_Py_Void();
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36178 PyObject *resultobj = 0;
36179 wxWindow *arg1 = (wxWindow *) 0 ;
36180 void *argp1 = 0 ;
36181 int res1 = 0 ;
36182 PyObject *swig_obj[1] ;
36183
36184 if (!args) SWIG_fail;
36185 swig_obj[0] = args;
36186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36187 if (!SWIG_IsOK(res1)) {
36188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36189 }
36190 arg1 = reinterpret_cast< wxWindow * >(argp1);
36191 {
36192 PyThreadState* __tstate = wxPyBeginAllowThreads();
36193 (arg1)->DissociateHandle();
36194 wxPyEndAllowThreads(__tstate);
36195 if (PyErr_Occurred()) SWIG_fail;
36196 }
36197 resultobj = SWIG_Py_Void();
36198 return resultobj;
36199 fail:
36200 return NULL;
36201 }
36202
36203
36204 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj = 0;
36206 wxWindow *arg1 = (wxWindow *) 0 ;
36207 wxPaintEvent *arg2 = 0 ;
36208 void *argp1 = 0 ;
36209 int res1 = 0 ;
36210 void *argp2 = 0 ;
36211 int res2 = 0 ;
36212 PyObject * obj0 = 0 ;
36213 PyObject * obj1 = 0 ;
36214 char * kwnames[] = {
36215 (char *) "self",(char *) "event", NULL
36216 };
36217
36218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36220 if (!SWIG_IsOK(res1)) {
36221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36222 }
36223 arg1 = reinterpret_cast< wxWindow * >(argp1);
36224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36225 if (!SWIG_IsOK(res2)) {
36226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36227 }
36228 if (!argp2) {
36229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36230 }
36231 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 (arg1)->OnPaint(*arg2);
36235 wxPyEndAllowThreads(__tstate);
36236 if (PyErr_Occurred()) SWIG_fail;
36237 }
36238 resultobj = SWIG_Py_Void();
36239 return resultobj;
36240 fail:
36241 return NULL;
36242 }
36243
36244
36245 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36246 PyObject *resultobj = 0;
36247 wxWindow *arg1 = (wxWindow *) 0 ;
36248 int arg2 ;
36249 bool result;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 int val2 ;
36253 int ecode2 = 0 ;
36254 PyObject * obj0 = 0 ;
36255 PyObject * obj1 = 0 ;
36256 char * kwnames[] = {
36257 (char *) "self",(char *) "orient", NULL
36258 };
36259
36260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36262 if (!SWIG_IsOK(res1)) {
36263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36264 }
36265 arg1 = reinterpret_cast< wxWindow * >(argp1);
36266 ecode2 = SWIG_AsVal_int(obj1, &val2);
36267 if (!SWIG_IsOK(ecode2)) {
36268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36269 }
36270 arg2 = static_cast< int >(val2);
36271 {
36272 PyThreadState* __tstate = wxPyBeginAllowThreads();
36273 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36274 wxPyEndAllowThreads(__tstate);
36275 if (PyErr_Occurred()) SWIG_fail;
36276 }
36277 {
36278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36279 }
36280 return resultobj;
36281 fail:
36282 return NULL;
36283 }
36284
36285
36286 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36287 PyObject *resultobj = 0;
36288 wxWindow *arg1 = (wxWindow *) 0 ;
36289 int arg2 ;
36290 int arg3 ;
36291 int arg4 ;
36292 int arg5 ;
36293 bool arg6 = (bool) true ;
36294 void *argp1 = 0 ;
36295 int res1 = 0 ;
36296 int val2 ;
36297 int ecode2 = 0 ;
36298 int val3 ;
36299 int ecode3 = 0 ;
36300 int val4 ;
36301 int ecode4 = 0 ;
36302 int val5 ;
36303 int ecode5 = 0 ;
36304 bool val6 ;
36305 int ecode6 = 0 ;
36306 PyObject * obj0 = 0 ;
36307 PyObject * obj1 = 0 ;
36308 PyObject * obj2 = 0 ;
36309 PyObject * obj3 = 0 ;
36310 PyObject * obj4 = 0 ;
36311 PyObject * obj5 = 0 ;
36312 char * kwnames[] = {
36313 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36314 };
36315
36316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36318 if (!SWIG_IsOK(res1)) {
36319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36320 }
36321 arg1 = reinterpret_cast< wxWindow * >(argp1);
36322 ecode2 = SWIG_AsVal_int(obj1, &val2);
36323 if (!SWIG_IsOK(ecode2)) {
36324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36325 }
36326 arg2 = static_cast< int >(val2);
36327 ecode3 = SWIG_AsVal_int(obj2, &val3);
36328 if (!SWIG_IsOK(ecode3)) {
36329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36330 }
36331 arg3 = static_cast< int >(val3);
36332 ecode4 = SWIG_AsVal_int(obj3, &val4);
36333 if (!SWIG_IsOK(ecode4)) {
36334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36335 }
36336 arg4 = static_cast< int >(val4);
36337 ecode5 = SWIG_AsVal_int(obj4, &val5);
36338 if (!SWIG_IsOK(ecode5)) {
36339 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36340 }
36341 arg5 = static_cast< int >(val5);
36342 if (obj5) {
36343 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36344 if (!SWIG_IsOK(ecode6)) {
36345 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36346 }
36347 arg6 = static_cast< bool >(val6);
36348 }
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 resultobj = SWIG_Py_Void();
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 int arg2 ;
36366 int arg3 ;
36367 bool arg4 = (bool) true ;
36368 void *argp1 = 0 ;
36369 int res1 = 0 ;
36370 int val2 ;
36371 int ecode2 = 0 ;
36372 int val3 ;
36373 int ecode3 = 0 ;
36374 bool val4 ;
36375 int ecode4 = 0 ;
36376 PyObject * obj0 = 0 ;
36377 PyObject * obj1 = 0 ;
36378 PyObject * obj2 = 0 ;
36379 PyObject * obj3 = 0 ;
36380 char * kwnames[] = {
36381 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36382 };
36383
36384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36386 if (!SWIG_IsOK(res1)) {
36387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36388 }
36389 arg1 = reinterpret_cast< wxWindow * >(argp1);
36390 ecode2 = SWIG_AsVal_int(obj1, &val2);
36391 if (!SWIG_IsOK(ecode2)) {
36392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36393 }
36394 arg2 = static_cast< int >(val2);
36395 ecode3 = SWIG_AsVal_int(obj2, &val3);
36396 if (!SWIG_IsOK(ecode3)) {
36397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36398 }
36399 arg3 = static_cast< int >(val3);
36400 if (obj3) {
36401 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36402 if (!SWIG_IsOK(ecode4)) {
36403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36404 }
36405 arg4 = static_cast< bool >(val4);
36406 }
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 (arg1)->SetScrollPos(arg2,arg3,arg4);
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 resultobj = SWIG_Py_Void();
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36421 PyObject *resultobj = 0;
36422 wxWindow *arg1 = (wxWindow *) 0 ;
36423 int arg2 ;
36424 int result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 int val2 ;
36428 int ecode2 = 0 ;
36429 PyObject * obj0 = 0 ;
36430 PyObject * obj1 = 0 ;
36431 char * kwnames[] = {
36432 (char *) "self",(char *) "orientation", NULL
36433 };
36434
36435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36437 if (!SWIG_IsOK(res1)) {
36438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36439 }
36440 arg1 = reinterpret_cast< wxWindow * >(argp1);
36441 ecode2 = SWIG_AsVal_int(obj1, &val2);
36442 if (!SWIG_IsOK(ecode2)) {
36443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36444 }
36445 arg2 = static_cast< int >(val2);
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_From_int(static_cast< int >(result));
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 int arg2 ;
36463 int result;
36464 void *argp1 = 0 ;
36465 int res1 = 0 ;
36466 int val2 ;
36467 int ecode2 = 0 ;
36468 PyObject * obj0 = 0 ;
36469 PyObject * obj1 = 0 ;
36470 char * kwnames[] = {
36471 (char *) "self",(char *) "orientation", NULL
36472 };
36473
36474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36476 if (!SWIG_IsOK(res1)) {
36477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36478 }
36479 arg1 = reinterpret_cast< wxWindow * >(argp1);
36480 ecode2 = SWIG_AsVal_int(obj1, &val2);
36481 if (!SWIG_IsOK(ecode2)) {
36482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36483 }
36484 arg2 = static_cast< int >(val2);
36485 {
36486 PyThreadState* __tstate = wxPyBeginAllowThreads();
36487 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36488 wxPyEndAllowThreads(__tstate);
36489 if (PyErr_Occurred()) SWIG_fail;
36490 }
36491 resultobj = SWIG_From_int(static_cast< int >(result));
36492 return resultobj;
36493 fail:
36494 return NULL;
36495 }
36496
36497
36498 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36499 PyObject *resultobj = 0;
36500 wxWindow *arg1 = (wxWindow *) 0 ;
36501 int arg2 ;
36502 int result;
36503 void *argp1 = 0 ;
36504 int res1 = 0 ;
36505 int val2 ;
36506 int ecode2 = 0 ;
36507 PyObject * obj0 = 0 ;
36508 PyObject * obj1 = 0 ;
36509 char * kwnames[] = {
36510 (char *) "self",(char *) "orientation", NULL
36511 };
36512
36513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36515 if (!SWIG_IsOK(res1)) {
36516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36517 }
36518 arg1 = reinterpret_cast< wxWindow * >(argp1);
36519 ecode2 = SWIG_AsVal_int(obj1, &val2);
36520 if (!SWIG_IsOK(ecode2)) {
36521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36522 }
36523 arg2 = static_cast< int >(val2);
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36527 wxPyEndAllowThreads(__tstate);
36528 if (PyErr_Occurred()) SWIG_fail;
36529 }
36530 resultobj = SWIG_From_int(static_cast< int >(result));
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj = 0;
36539 wxWindow *arg1 = (wxWindow *) 0 ;
36540 int arg2 ;
36541 int arg3 ;
36542 wxRect *arg4 = (wxRect *) NULL ;
36543 void *argp1 = 0 ;
36544 int res1 = 0 ;
36545 int val2 ;
36546 int ecode2 = 0 ;
36547 int val3 ;
36548 int ecode3 = 0 ;
36549 void *argp4 = 0 ;
36550 int res4 = 0 ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 PyObject * obj2 = 0 ;
36554 PyObject * obj3 = 0 ;
36555 char * kwnames[] = {
36556 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36557 };
36558
36559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36561 if (!SWIG_IsOK(res1)) {
36562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36563 }
36564 arg1 = reinterpret_cast< wxWindow * >(argp1);
36565 ecode2 = SWIG_AsVal_int(obj1, &val2);
36566 if (!SWIG_IsOK(ecode2)) {
36567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36568 }
36569 arg2 = static_cast< int >(val2);
36570 ecode3 = SWIG_AsVal_int(obj2, &val3);
36571 if (!SWIG_IsOK(ecode3)) {
36572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36573 }
36574 arg3 = static_cast< int >(val3);
36575 if (obj3) {
36576 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36577 if (!SWIG_IsOK(res4)) {
36578 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36579 }
36580 arg4 = reinterpret_cast< wxRect * >(argp4);
36581 }
36582 {
36583 PyThreadState* __tstate = wxPyBeginAllowThreads();
36584 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36585 wxPyEndAllowThreads(__tstate);
36586 if (PyErr_Occurred()) SWIG_fail;
36587 }
36588 resultobj = SWIG_Py_Void();
36589 return resultobj;
36590 fail:
36591 return NULL;
36592 }
36593
36594
36595 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36596 PyObject *resultobj = 0;
36597 wxWindow *arg1 = (wxWindow *) 0 ;
36598 int arg2 ;
36599 bool result;
36600 void *argp1 = 0 ;
36601 int res1 = 0 ;
36602 int val2 ;
36603 int ecode2 = 0 ;
36604 PyObject * obj0 = 0 ;
36605 PyObject * obj1 = 0 ;
36606 char * kwnames[] = {
36607 (char *) "self",(char *) "lines", NULL
36608 };
36609
36610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36612 if (!SWIG_IsOK(res1)) {
36613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36614 }
36615 arg1 = reinterpret_cast< wxWindow * >(argp1);
36616 ecode2 = SWIG_AsVal_int(obj1, &val2);
36617 if (!SWIG_IsOK(ecode2)) {
36618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36619 }
36620 arg2 = static_cast< int >(val2);
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 result = (bool)(arg1)->ScrollLines(arg2);
36624 wxPyEndAllowThreads(__tstate);
36625 if (PyErr_Occurred()) SWIG_fail;
36626 }
36627 {
36628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36629 }
36630 return resultobj;
36631 fail:
36632 return NULL;
36633 }
36634
36635
36636 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36637 PyObject *resultobj = 0;
36638 wxWindow *arg1 = (wxWindow *) 0 ;
36639 int arg2 ;
36640 bool result;
36641 void *argp1 = 0 ;
36642 int res1 = 0 ;
36643 int val2 ;
36644 int ecode2 = 0 ;
36645 PyObject * obj0 = 0 ;
36646 PyObject * obj1 = 0 ;
36647 char * kwnames[] = {
36648 (char *) "self",(char *) "pages", NULL
36649 };
36650
36651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36653 if (!SWIG_IsOK(res1)) {
36654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36655 }
36656 arg1 = reinterpret_cast< wxWindow * >(argp1);
36657 ecode2 = SWIG_AsVal_int(obj1, &val2);
36658 if (!SWIG_IsOK(ecode2)) {
36659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36660 }
36661 arg2 = static_cast< int >(val2);
36662 {
36663 PyThreadState* __tstate = wxPyBeginAllowThreads();
36664 result = (bool)(arg1)->ScrollPages(arg2);
36665 wxPyEndAllowThreads(__tstate);
36666 if (PyErr_Occurred()) SWIG_fail;
36667 }
36668 {
36669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36670 }
36671 return resultobj;
36672 fail:
36673 return NULL;
36674 }
36675
36676
36677 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36678 PyObject *resultobj = 0;
36679 wxWindow *arg1 = (wxWindow *) 0 ;
36680 bool result;
36681 void *argp1 = 0 ;
36682 int res1 = 0 ;
36683 PyObject *swig_obj[1] ;
36684
36685 if (!args) SWIG_fail;
36686 swig_obj[0] = args;
36687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36688 if (!SWIG_IsOK(res1)) {
36689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36690 }
36691 arg1 = reinterpret_cast< wxWindow * >(argp1);
36692 {
36693 PyThreadState* __tstate = wxPyBeginAllowThreads();
36694 result = (bool)(arg1)->LineUp();
36695 wxPyEndAllowThreads(__tstate);
36696 if (PyErr_Occurred()) SWIG_fail;
36697 }
36698 {
36699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36700 }
36701 return resultobj;
36702 fail:
36703 return NULL;
36704 }
36705
36706
36707 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36708 PyObject *resultobj = 0;
36709 wxWindow *arg1 = (wxWindow *) 0 ;
36710 bool result;
36711 void *argp1 = 0 ;
36712 int res1 = 0 ;
36713 PyObject *swig_obj[1] ;
36714
36715 if (!args) SWIG_fail;
36716 swig_obj[0] = args;
36717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36720 }
36721 arg1 = reinterpret_cast< wxWindow * >(argp1);
36722 {
36723 PyThreadState* __tstate = wxPyBeginAllowThreads();
36724 result = (bool)(arg1)->LineDown();
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 {
36729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36730 }
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36738 PyObject *resultobj = 0;
36739 wxWindow *arg1 = (wxWindow *) 0 ;
36740 bool result;
36741 void *argp1 = 0 ;
36742 int res1 = 0 ;
36743 PyObject *swig_obj[1] ;
36744
36745 if (!args) SWIG_fail;
36746 swig_obj[0] = args;
36747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36748 if (!SWIG_IsOK(res1)) {
36749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36750 }
36751 arg1 = reinterpret_cast< wxWindow * >(argp1);
36752 {
36753 PyThreadState* __tstate = wxPyBeginAllowThreads();
36754 result = (bool)(arg1)->PageUp();
36755 wxPyEndAllowThreads(__tstate);
36756 if (PyErr_Occurred()) SWIG_fail;
36757 }
36758 {
36759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36760 }
36761 return resultobj;
36762 fail:
36763 return NULL;
36764 }
36765
36766
36767 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36768 PyObject *resultobj = 0;
36769 wxWindow *arg1 = (wxWindow *) 0 ;
36770 bool result;
36771 void *argp1 = 0 ;
36772 int res1 = 0 ;
36773 PyObject *swig_obj[1] ;
36774
36775 if (!args) SWIG_fail;
36776 swig_obj[0] = args;
36777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36778 if (!SWIG_IsOK(res1)) {
36779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36780 }
36781 arg1 = reinterpret_cast< wxWindow * >(argp1);
36782 {
36783 PyThreadState* __tstate = wxPyBeginAllowThreads();
36784 result = (bool)(arg1)->PageDown();
36785 wxPyEndAllowThreads(__tstate);
36786 if (PyErr_Occurred()) SWIG_fail;
36787 }
36788 {
36789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36790 }
36791 return resultobj;
36792 fail:
36793 return NULL;
36794 }
36795
36796
36797 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36798 PyObject *resultobj = 0;
36799 wxWindow *arg1 = (wxWindow *) 0 ;
36800 wxString *arg2 = 0 ;
36801 void *argp1 = 0 ;
36802 int res1 = 0 ;
36803 bool temp2 = false ;
36804 PyObject * obj0 = 0 ;
36805 PyObject * obj1 = 0 ;
36806 char * kwnames[] = {
36807 (char *) "self",(char *) "text", NULL
36808 };
36809
36810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36812 if (!SWIG_IsOK(res1)) {
36813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36814 }
36815 arg1 = reinterpret_cast< wxWindow * >(argp1);
36816 {
36817 arg2 = wxString_in_helper(obj1);
36818 if (arg2 == NULL) SWIG_fail;
36819 temp2 = true;
36820 }
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 (arg1)->SetHelpText((wxString const &)*arg2);
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 resultobj = SWIG_Py_Void();
36828 {
36829 if (temp2)
36830 delete arg2;
36831 }
36832 return resultobj;
36833 fail:
36834 {
36835 if (temp2)
36836 delete arg2;
36837 }
36838 return NULL;
36839 }
36840
36841
36842 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36843 PyObject *resultobj = 0;
36844 wxWindow *arg1 = (wxWindow *) 0 ;
36845 wxString *arg2 = 0 ;
36846 void *argp1 = 0 ;
36847 int res1 = 0 ;
36848 bool temp2 = false ;
36849 PyObject * obj0 = 0 ;
36850 PyObject * obj1 = 0 ;
36851 char * kwnames[] = {
36852 (char *) "self",(char *) "text", NULL
36853 };
36854
36855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36857 if (!SWIG_IsOK(res1)) {
36858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36859 }
36860 arg1 = reinterpret_cast< wxWindow * >(argp1);
36861 {
36862 arg2 = wxString_in_helper(obj1);
36863 if (arg2 == NULL) SWIG_fail;
36864 temp2 = true;
36865 }
36866 {
36867 PyThreadState* __tstate = wxPyBeginAllowThreads();
36868 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36869 wxPyEndAllowThreads(__tstate);
36870 if (PyErr_Occurred()) SWIG_fail;
36871 }
36872 resultobj = SWIG_Py_Void();
36873 {
36874 if (temp2)
36875 delete arg2;
36876 }
36877 return resultobj;
36878 fail:
36879 {
36880 if (temp2)
36881 delete arg2;
36882 }
36883 return NULL;
36884 }
36885
36886
36887 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36888 PyObject *resultobj = 0;
36889 wxWindow *arg1 = (wxWindow *) 0 ;
36890 wxString result;
36891 void *argp1 = 0 ;
36892 int res1 = 0 ;
36893 PyObject *swig_obj[1] ;
36894
36895 if (!args) SWIG_fail;
36896 swig_obj[0] = args;
36897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36898 if (!SWIG_IsOK(res1)) {
36899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36900 }
36901 arg1 = reinterpret_cast< wxWindow * >(argp1);
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = ((wxWindow const *)arg1)->GetHelpText();
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 {
36909 #if wxUSE_UNICODE
36910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36911 #else
36912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36913 #endif
36914 }
36915 return resultobj;
36916 fail:
36917 return NULL;
36918 }
36919
36920
36921 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36922 PyObject *resultobj = 0;
36923 wxWindow *arg1 = (wxWindow *) 0 ;
36924 wxString *arg2 = 0 ;
36925 void *argp1 = 0 ;
36926 int res1 = 0 ;
36927 bool temp2 = false ;
36928 PyObject * obj0 = 0 ;
36929 PyObject * obj1 = 0 ;
36930 char * kwnames[] = {
36931 (char *) "self",(char *) "tip", NULL
36932 };
36933
36934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36938 }
36939 arg1 = reinterpret_cast< wxWindow * >(argp1);
36940 {
36941 arg2 = wxString_in_helper(obj1);
36942 if (arg2 == NULL) SWIG_fail;
36943 temp2 = true;
36944 }
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 (arg1)->SetToolTip((wxString const &)*arg2);
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 resultobj = SWIG_Py_Void();
36952 {
36953 if (temp2)
36954 delete arg2;
36955 }
36956 return resultobj;
36957 fail:
36958 {
36959 if (temp2)
36960 delete arg2;
36961 }
36962 return NULL;
36963 }
36964
36965
36966 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36967 PyObject *resultobj = 0;
36968 wxWindow *arg1 = (wxWindow *) 0 ;
36969 wxToolTip *arg2 = (wxToolTip *) 0 ;
36970 void *argp1 = 0 ;
36971 int res1 = 0 ;
36972 int res2 = 0 ;
36973 PyObject * obj0 = 0 ;
36974 PyObject * obj1 = 0 ;
36975 char * kwnames[] = {
36976 (char *) "self",(char *) "tip", NULL
36977 };
36978
36979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36981 if (!SWIG_IsOK(res1)) {
36982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36983 }
36984 arg1 = reinterpret_cast< wxWindow * >(argp1);
36985 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36986 if (!SWIG_IsOK(res2)) {
36987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36988 }
36989 {
36990 PyThreadState* __tstate = wxPyBeginAllowThreads();
36991 (arg1)->SetToolTip(arg2);
36992 wxPyEndAllowThreads(__tstate);
36993 if (PyErr_Occurred()) SWIG_fail;
36994 }
36995 resultobj = SWIG_Py_Void();
36996 return resultobj;
36997 fail:
36998 return NULL;
36999 }
37000
37001
37002 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37003 PyObject *resultobj = 0;
37004 wxWindow *arg1 = (wxWindow *) 0 ;
37005 wxToolTip *result = 0 ;
37006 void *argp1 = 0 ;
37007 int res1 = 0 ;
37008 PyObject *swig_obj[1] ;
37009
37010 if (!args) SWIG_fail;
37011 swig_obj[0] = args;
37012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37013 if (!SWIG_IsOK(res1)) {
37014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37015 }
37016 arg1 = reinterpret_cast< wxWindow * >(argp1);
37017 {
37018 PyThreadState* __tstate = wxPyBeginAllowThreads();
37019 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37020 wxPyEndAllowThreads(__tstate);
37021 if (PyErr_Occurred()) SWIG_fail;
37022 }
37023 {
37024 resultobj = wxPyMake_wxObject(result, (bool)0);
37025 }
37026 return resultobj;
37027 fail:
37028 return NULL;
37029 }
37030
37031
37032 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37033 PyObject *resultobj = 0;
37034 wxWindow *arg1 = (wxWindow *) 0 ;
37035 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37036 void *argp1 = 0 ;
37037 int res1 = 0 ;
37038 int res2 = 0 ;
37039 PyObject * obj0 = 0 ;
37040 PyObject * obj1 = 0 ;
37041 char * kwnames[] = {
37042 (char *) "self",(char *) "dropTarget", NULL
37043 };
37044
37045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37047 if (!SWIG_IsOK(res1)) {
37048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37049 }
37050 arg1 = reinterpret_cast< wxWindow * >(argp1);
37051 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37052 if (!SWIG_IsOK(res2)) {
37053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37054 }
37055 {
37056 PyThreadState* __tstate = wxPyBeginAllowThreads();
37057 (arg1)->SetDropTarget(arg2);
37058 wxPyEndAllowThreads(__tstate);
37059 if (PyErr_Occurred()) SWIG_fail;
37060 }
37061 resultobj = SWIG_Py_Void();
37062 return resultobj;
37063 fail:
37064 return NULL;
37065 }
37066
37067
37068 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37069 PyObject *resultobj = 0;
37070 wxWindow *arg1 = (wxWindow *) 0 ;
37071 wxPyDropTarget *result = 0 ;
37072 void *argp1 = 0 ;
37073 int res1 = 0 ;
37074 PyObject *swig_obj[1] ;
37075
37076 if (!args) SWIG_fail;
37077 swig_obj[0] = args;
37078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37079 if (!SWIG_IsOK(res1)) {
37080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37081 }
37082 arg1 = reinterpret_cast< wxWindow * >(argp1);
37083 {
37084 PyThreadState* __tstate = wxPyBeginAllowThreads();
37085 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37086 wxPyEndAllowThreads(__tstate);
37087 if (PyErr_Occurred()) SWIG_fail;
37088 }
37089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37090 return resultobj;
37091 fail:
37092 return NULL;
37093 }
37094
37095
37096 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37097 PyObject *resultobj = 0;
37098 wxWindow *arg1 = (wxWindow *) 0 ;
37099 bool arg2 ;
37100 void *argp1 = 0 ;
37101 int res1 = 0 ;
37102 bool val2 ;
37103 int ecode2 = 0 ;
37104 PyObject * obj0 = 0 ;
37105 PyObject * obj1 = 0 ;
37106 char * kwnames[] = {
37107 (char *) "self",(char *) "accept", NULL
37108 };
37109
37110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37112 if (!SWIG_IsOK(res1)) {
37113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37114 }
37115 arg1 = reinterpret_cast< wxWindow * >(argp1);
37116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37117 if (!SWIG_IsOK(ecode2)) {
37118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37119 }
37120 arg2 = static_cast< bool >(val2);
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 (arg1)->DragAcceptFiles(arg2);
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 resultobj = SWIG_Py_Void();
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj = 0;
37136 wxWindow *arg1 = (wxWindow *) 0 ;
37137 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37138 void *argp1 = 0 ;
37139 int res1 = 0 ;
37140 int res2 = 0 ;
37141 PyObject * obj0 = 0 ;
37142 PyObject * obj1 = 0 ;
37143 char * kwnames[] = {
37144 (char *) "self",(char *) "constraints", NULL
37145 };
37146
37147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",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_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37151 }
37152 arg1 = reinterpret_cast< wxWindow * >(argp1);
37153 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37154 if (!SWIG_IsOK(res2)) {
37155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37156 }
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 (arg1)->SetConstraints(arg2);
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 resultobj = SWIG_Py_Void();
37164 return resultobj;
37165 fail:
37166 return NULL;
37167 }
37168
37169
37170 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37171 PyObject *resultobj = 0;
37172 wxWindow *arg1 = (wxWindow *) 0 ;
37173 wxLayoutConstraints *result = 0 ;
37174 void *argp1 = 0 ;
37175 int res1 = 0 ;
37176 PyObject *swig_obj[1] ;
37177
37178 if (!args) SWIG_fail;
37179 swig_obj[0] = args;
37180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37181 if (!SWIG_IsOK(res1)) {
37182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37183 }
37184 arg1 = reinterpret_cast< wxWindow * >(argp1);
37185 {
37186 PyThreadState* __tstate = wxPyBeginAllowThreads();
37187 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37188 wxPyEndAllowThreads(__tstate);
37189 if (PyErr_Occurred()) SWIG_fail;
37190 }
37191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37199 PyObject *resultobj = 0;
37200 wxWindow *arg1 = (wxWindow *) 0 ;
37201 bool arg2 ;
37202 void *argp1 = 0 ;
37203 int res1 = 0 ;
37204 bool val2 ;
37205 int ecode2 = 0 ;
37206 PyObject * obj0 = 0 ;
37207 PyObject * obj1 = 0 ;
37208 char * kwnames[] = {
37209 (char *) "self",(char *) "autoLayout", NULL
37210 };
37211
37212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37219 if (!SWIG_IsOK(ecode2)) {
37220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37221 }
37222 arg2 = static_cast< bool >(val2);
37223 {
37224 PyThreadState* __tstate = wxPyBeginAllowThreads();
37225 (arg1)->SetAutoLayout(arg2);
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 resultobj = SWIG_Py_Void();
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37237 PyObject *resultobj = 0;
37238 wxWindow *arg1 = (wxWindow *) 0 ;
37239 bool result;
37240 void *argp1 = 0 ;
37241 int res1 = 0 ;
37242 PyObject *swig_obj[1] ;
37243
37244 if (!args) SWIG_fail;
37245 swig_obj[0] = args;
37246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37247 if (!SWIG_IsOK(res1)) {
37248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37249 }
37250 arg1 = reinterpret_cast< wxWindow * >(argp1);
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 {
37258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37259 }
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 bool result;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 PyObject *swig_obj[1] ;
37273
37274 if (!args) SWIG_fail;
37275 swig_obj[0] = args;
37276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37279 }
37280 arg1 = reinterpret_cast< wxWindow * >(argp1);
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 result = (bool)(arg1)->Layout();
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 {
37288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37289 }
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37297 PyObject *resultobj = 0;
37298 wxWindow *arg1 = (wxWindow *) 0 ;
37299 wxSizer *arg2 = (wxSizer *) 0 ;
37300 bool arg3 = (bool) true ;
37301 void *argp1 = 0 ;
37302 int res1 = 0 ;
37303 int res2 = 0 ;
37304 bool val3 ;
37305 int ecode3 = 0 ;
37306 PyObject * obj0 = 0 ;
37307 PyObject * obj1 = 0 ;
37308 PyObject * obj2 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37322 }
37323 if (obj2) {
37324 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37325 if (!SWIG_IsOK(ecode3)) {
37326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37327 }
37328 arg3 = static_cast< bool >(val3);
37329 }
37330 {
37331 PyThreadState* __tstate = wxPyBeginAllowThreads();
37332 (arg1)->SetSizer(arg2,arg3);
37333 wxPyEndAllowThreads(__tstate);
37334 if (PyErr_Occurred()) SWIG_fail;
37335 }
37336 resultobj = SWIG_Py_Void();
37337 return resultobj;
37338 fail:
37339 return NULL;
37340 }
37341
37342
37343 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37344 PyObject *resultobj = 0;
37345 wxWindow *arg1 = (wxWindow *) 0 ;
37346 wxSizer *arg2 = (wxSizer *) 0 ;
37347 bool arg3 = (bool) true ;
37348 void *argp1 = 0 ;
37349 int res1 = 0 ;
37350 int res2 = 0 ;
37351 bool val3 ;
37352 int ecode3 = 0 ;
37353 PyObject * obj0 = 0 ;
37354 PyObject * obj1 = 0 ;
37355 PyObject * obj2 = 0 ;
37356 char * kwnames[] = {
37357 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37358 };
37359
37360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37367 if (!SWIG_IsOK(res2)) {
37368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37369 }
37370 if (obj2) {
37371 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37372 if (!SWIG_IsOK(ecode3)) {
37373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37374 }
37375 arg3 = static_cast< bool >(val3);
37376 }
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 (arg1)->SetSizerAndFit(arg2,arg3);
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_Py_Void();
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37391 PyObject *resultobj = 0;
37392 wxWindow *arg1 = (wxWindow *) 0 ;
37393 wxSizer *result = 0 ;
37394 void *argp1 = 0 ;
37395 int res1 = 0 ;
37396 PyObject *swig_obj[1] ;
37397
37398 if (!args) SWIG_fail;
37399 swig_obj[0] = args;
37400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37401 if (!SWIG_IsOK(res1)) {
37402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37403 }
37404 arg1 = reinterpret_cast< wxWindow * >(argp1);
37405 {
37406 PyThreadState* __tstate = wxPyBeginAllowThreads();
37407 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37408 wxPyEndAllowThreads(__tstate);
37409 if (PyErr_Occurred()) SWIG_fail;
37410 }
37411 {
37412 resultobj = wxPyMake_wxObject(result, (bool)0);
37413 }
37414 return resultobj;
37415 fail:
37416 return NULL;
37417 }
37418
37419
37420 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37421 PyObject *resultobj = 0;
37422 wxWindow *arg1 = (wxWindow *) 0 ;
37423 wxSizer *arg2 = (wxSizer *) 0 ;
37424 void *argp1 = 0 ;
37425 int res1 = 0 ;
37426 void *argp2 = 0 ;
37427 int res2 = 0 ;
37428 PyObject * obj0 = 0 ;
37429 PyObject * obj1 = 0 ;
37430 char * kwnames[] = {
37431 (char *) "self",(char *) "sizer", NULL
37432 };
37433
37434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37436 if (!SWIG_IsOK(res1)) {
37437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37438 }
37439 arg1 = reinterpret_cast< wxWindow * >(argp1);
37440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37441 if (!SWIG_IsOK(res2)) {
37442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37443 }
37444 arg2 = reinterpret_cast< wxSizer * >(argp2);
37445 {
37446 PyThreadState* __tstate = wxPyBeginAllowThreads();
37447 (arg1)->SetContainingSizer(arg2);
37448 wxPyEndAllowThreads(__tstate);
37449 if (PyErr_Occurred()) SWIG_fail;
37450 }
37451 resultobj = SWIG_Py_Void();
37452 return resultobj;
37453 fail:
37454 return NULL;
37455 }
37456
37457
37458 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37459 PyObject *resultobj = 0;
37460 wxWindow *arg1 = (wxWindow *) 0 ;
37461 wxSizer *result = 0 ;
37462 void *argp1 = 0 ;
37463 int res1 = 0 ;
37464 PyObject *swig_obj[1] ;
37465
37466 if (!args) SWIG_fail;
37467 swig_obj[0] = args;
37468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37469 if (!SWIG_IsOK(res1)) {
37470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37471 }
37472 arg1 = reinterpret_cast< wxWindow * >(argp1);
37473 {
37474 PyThreadState* __tstate = wxPyBeginAllowThreads();
37475 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37476 wxPyEndAllowThreads(__tstate);
37477 if (PyErr_Occurred()) SWIG_fail;
37478 }
37479 {
37480 resultobj = wxPyMake_wxObject(result, (bool)0);
37481 }
37482 return resultobj;
37483 fail:
37484 return NULL;
37485 }
37486
37487
37488 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37489 PyObject *resultobj = 0;
37490 wxWindow *arg1 = (wxWindow *) 0 ;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 PyObject *swig_obj[1] ;
37494
37495 if (!args) SWIG_fail;
37496 swig_obj[0] = args;
37497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37498 if (!SWIG_IsOK(res1)) {
37499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37500 }
37501 arg1 = reinterpret_cast< wxWindow * >(argp1);
37502 {
37503 PyThreadState* __tstate = wxPyBeginAllowThreads();
37504 (arg1)->InheritAttributes();
37505 wxPyEndAllowThreads(__tstate);
37506 if (PyErr_Occurred()) SWIG_fail;
37507 }
37508 resultobj = SWIG_Py_Void();
37509 return resultobj;
37510 fail:
37511 return NULL;
37512 }
37513
37514
37515 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37516 PyObject *resultobj = 0;
37517 wxWindow *arg1 = (wxWindow *) 0 ;
37518 bool result;
37519 void *argp1 = 0 ;
37520 int res1 = 0 ;
37521 PyObject *swig_obj[1] ;
37522
37523 if (!args) SWIG_fail;
37524 swig_obj[0] = args;
37525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37526 if (!SWIG_IsOK(res1)) {
37527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37528 }
37529 arg1 = reinterpret_cast< wxWindow * >(argp1);
37530 {
37531 PyThreadState* __tstate = wxPyBeginAllowThreads();
37532 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37533 wxPyEndAllowThreads(__tstate);
37534 if (PyErr_Occurred()) SWIG_fail;
37535 }
37536 {
37537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37538 }
37539 return resultobj;
37540 fail:
37541 return NULL;
37542 }
37543
37544
37545 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37546 PyObject *obj;
37547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37548 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37549 return SWIG_Py_Void();
37550 }
37551
37552 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37553 return SWIG_Python_InitShadowInstance(args);
37554 }
37555
37556 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37557 PyObject *resultobj = 0;
37558 long arg1 ;
37559 wxWindow *arg2 = (wxWindow *) NULL ;
37560 wxWindow *result = 0 ;
37561 long val1 ;
37562 int ecode1 = 0 ;
37563 void *argp2 = 0 ;
37564 int res2 = 0 ;
37565 PyObject * obj0 = 0 ;
37566 PyObject * obj1 = 0 ;
37567 char * kwnames[] = {
37568 (char *) "id",(char *) "parent", NULL
37569 };
37570
37571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37572 ecode1 = SWIG_AsVal_long(obj0, &val1);
37573 if (!SWIG_IsOK(ecode1)) {
37574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37575 }
37576 arg1 = static_cast< long >(val1);
37577 if (obj1) {
37578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37579 if (!SWIG_IsOK(res2)) {
37580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37581 }
37582 arg2 = reinterpret_cast< wxWindow * >(argp2);
37583 }
37584 {
37585 if (!wxPyCheckForApp()) SWIG_fail;
37586 PyThreadState* __tstate = wxPyBeginAllowThreads();
37587 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37588 wxPyEndAllowThreads(__tstate);
37589 if (PyErr_Occurred()) SWIG_fail;
37590 }
37591 {
37592 resultobj = wxPyMake_wxObject(result, 0);
37593 }
37594 return resultobj;
37595 fail:
37596 return NULL;
37597 }
37598
37599
37600 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37601 PyObject *resultobj = 0;
37602 wxString *arg1 = 0 ;
37603 wxWindow *arg2 = (wxWindow *) NULL ;
37604 wxWindow *result = 0 ;
37605 bool temp1 = false ;
37606 void *argp2 = 0 ;
37607 int res2 = 0 ;
37608 PyObject * obj0 = 0 ;
37609 PyObject * obj1 = 0 ;
37610 char * kwnames[] = {
37611 (char *) "name",(char *) "parent", NULL
37612 };
37613
37614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37615 {
37616 arg1 = wxString_in_helper(obj0);
37617 if (arg1 == NULL) SWIG_fail;
37618 temp1 = true;
37619 }
37620 if (obj1) {
37621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37622 if (!SWIG_IsOK(res2)) {
37623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37624 }
37625 arg2 = reinterpret_cast< wxWindow * >(argp2);
37626 }
37627 {
37628 if (!wxPyCheckForApp()) SWIG_fail;
37629 PyThreadState* __tstate = wxPyBeginAllowThreads();
37630 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37631 wxPyEndAllowThreads(__tstate);
37632 if (PyErr_Occurred()) SWIG_fail;
37633 }
37634 {
37635 resultobj = wxPyMake_wxObject(result, 0);
37636 }
37637 {
37638 if (temp1)
37639 delete arg1;
37640 }
37641 return resultobj;
37642 fail:
37643 {
37644 if (temp1)
37645 delete arg1;
37646 }
37647 return NULL;
37648 }
37649
37650
37651 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37652 PyObject *resultobj = 0;
37653 wxString *arg1 = 0 ;
37654 wxWindow *arg2 = (wxWindow *) NULL ;
37655 wxWindow *result = 0 ;
37656 bool temp1 = false ;
37657 void *argp2 = 0 ;
37658 int res2 = 0 ;
37659 PyObject * obj0 = 0 ;
37660 PyObject * obj1 = 0 ;
37661 char * kwnames[] = {
37662 (char *) "label",(char *) "parent", NULL
37663 };
37664
37665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37666 {
37667 arg1 = wxString_in_helper(obj0);
37668 if (arg1 == NULL) SWIG_fail;
37669 temp1 = true;
37670 }
37671 if (obj1) {
37672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37673 if (!SWIG_IsOK(res2)) {
37674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37675 }
37676 arg2 = reinterpret_cast< wxWindow * >(argp2);
37677 }
37678 {
37679 if (!wxPyCheckForApp()) SWIG_fail;
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 {
37686 resultobj = wxPyMake_wxObject(result, 0);
37687 }
37688 {
37689 if (temp1)
37690 delete arg1;
37691 }
37692 return resultobj;
37693 fail:
37694 {
37695 if (temp1)
37696 delete arg1;
37697 }
37698 return NULL;
37699 }
37700
37701
37702 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37703 PyObject *resultobj = 0;
37704 wxWindow *arg1 = (wxWindow *) 0 ;
37705 unsigned long arg2 ;
37706 wxWindow *result = 0 ;
37707 void *argp1 = 0 ;
37708 int res1 = 0 ;
37709 unsigned long val2 ;
37710 int ecode2 = 0 ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char * kwnames[] = {
37714 (char *) "parent",(char *) "_hWnd", NULL
37715 };
37716
37717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37721 }
37722 arg1 = reinterpret_cast< wxWindow * >(argp1);
37723 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37724 if (!SWIG_IsOK(ecode2)) {
37725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37726 }
37727 arg2 = static_cast< unsigned long >(val2);
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 {
37735 resultobj = wxPyMake_wxObject(result, 0);
37736 }
37737 return resultobj;
37738 fail:
37739 return NULL;
37740 }
37741
37742
37743 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37744 PyObject *resultobj = 0;
37745 PyObject *result = 0 ;
37746
37747 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37748 {
37749 PyThreadState* __tstate = wxPyBeginAllowThreads();
37750 result = (PyObject *)GetTopLevelWindows();
37751 wxPyEndAllowThreads(__tstate);
37752 if (PyErr_Occurred()) SWIG_fail;
37753 }
37754 resultobj = result;
37755 return resultobj;
37756 fail:
37757 return NULL;
37758 }
37759
37760
37761 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37762 PyObject *resultobj = 0;
37763 wxValidator *result = 0 ;
37764
37765 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = (wxValidator *)new wxValidator();
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37780 PyObject *resultobj = 0;
37781 wxValidator *arg1 = (wxValidator *) 0 ;
37782 wxValidator *result = 0 ;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 PyObject *swig_obj[1] ;
37786
37787 if (!args) SWIG_fail;
37788 swig_obj[0] = args;
37789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37790 if (!SWIG_IsOK(res1)) {
37791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37792 }
37793 arg1 = reinterpret_cast< wxValidator * >(argp1);
37794 {
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 result = (wxValidator *)(arg1)->Clone();
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 {
37801 resultobj = wxPyMake_wxObject(result, 0);
37802 }
37803 return resultobj;
37804 fail:
37805 return NULL;
37806 }
37807
37808
37809 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37810 PyObject *resultobj = 0;
37811 wxValidator *arg1 = (wxValidator *) 0 ;
37812 wxWindow *arg2 = (wxWindow *) 0 ;
37813 bool result;
37814 void *argp1 = 0 ;
37815 int res1 = 0 ;
37816 void *argp2 = 0 ;
37817 int res2 = 0 ;
37818 PyObject * obj0 = 0 ;
37819 PyObject * obj1 = 0 ;
37820 char * kwnames[] = {
37821 (char *) "self",(char *) "parent", NULL
37822 };
37823
37824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37826 if (!SWIG_IsOK(res1)) {
37827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37828 }
37829 arg1 = reinterpret_cast< wxValidator * >(argp1);
37830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res2)) {
37832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37833 }
37834 arg2 = reinterpret_cast< wxWindow * >(argp2);
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 result = (bool)(arg1)->Validate(arg2);
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 {
37842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37843 }
37844 return resultobj;
37845 fail:
37846 return NULL;
37847 }
37848
37849
37850 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37851 PyObject *resultobj = 0;
37852 wxValidator *arg1 = (wxValidator *) 0 ;
37853 bool result;
37854 void *argp1 = 0 ;
37855 int res1 = 0 ;
37856 PyObject *swig_obj[1] ;
37857
37858 if (!args) SWIG_fail;
37859 swig_obj[0] = args;
37860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37861 if (!SWIG_IsOK(res1)) {
37862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37863 }
37864 arg1 = reinterpret_cast< wxValidator * >(argp1);
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 result = (bool)(arg1)->TransferToWindow();
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 {
37872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37873 }
37874 return resultobj;
37875 fail:
37876 return NULL;
37877 }
37878
37879
37880 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37881 PyObject *resultobj = 0;
37882 wxValidator *arg1 = (wxValidator *) 0 ;
37883 bool result;
37884 void *argp1 = 0 ;
37885 int res1 = 0 ;
37886 PyObject *swig_obj[1] ;
37887
37888 if (!args) SWIG_fail;
37889 swig_obj[0] = args;
37890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37893 }
37894 arg1 = reinterpret_cast< wxValidator * >(argp1);
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 result = (bool)(arg1)->TransferFromWindow();
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 {
37902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37903 }
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *resultobj = 0;
37912 wxValidator *arg1 = (wxValidator *) 0 ;
37913 wxWindow *result = 0 ;
37914 void *argp1 = 0 ;
37915 int res1 = 0 ;
37916 PyObject *swig_obj[1] ;
37917
37918 if (!args) SWIG_fail;
37919 swig_obj[0] = args;
37920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37921 if (!SWIG_IsOK(res1)) {
37922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37923 }
37924 arg1 = reinterpret_cast< wxValidator * >(argp1);
37925 {
37926 PyThreadState* __tstate = wxPyBeginAllowThreads();
37927 result = (wxWindow *)(arg1)->GetWindow();
37928 wxPyEndAllowThreads(__tstate);
37929 if (PyErr_Occurred()) SWIG_fail;
37930 }
37931 {
37932 resultobj = wxPyMake_wxObject(result, 0);
37933 }
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37941 PyObject *resultobj = 0;
37942 wxValidator *arg1 = (wxValidator *) 0 ;
37943 wxWindow *arg2 = (wxWindow *) 0 ;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 void *argp2 = 0 ;
37947 int res2 = 0 ;
37948 PyObject * obj0 = 0 ;
37949 PyObject * obj1 = 0 ;
37950 char * kwnames[] = {
37951 (char *) "self",(char *) "window", NULL
37952 };
37953
37954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37958 }
37959 arg1 = reinterpret_cast< wxValidator * >(argp1);
37960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37961 if (!SWIG_IsOK(res2)) {
37962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37963 }
37964 arg2 = reinterpret_cast< wxWindow * >(argp2);
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 (arg1)->SetWindow(arg2);
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 resultobj = SWIG_Py_Void();
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37979 PyObject *resultobj = 0;
37980 bool result;
37981
37982 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 result = (bool)wxValidator::IsSilent();
37986 wxPyEndAllowThreads(__tstate);
37987 if (PyErr_Occurred()) SWIG_fail;
37988 }
37989 {
37990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37991 }
37992 return resultobj;
37993 fail:
37994 return NULL;
37995 }
37996
37997
37998 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37999 PyObject *resultobj = 0;
38000 int arg1 = (int) true ;
38001 int val1 ;
38002 int ecode1 = 0 ;
38003 PyObject * obj0 = 0 ;
38004 char * kwnames[] = {
38005 (char *) "doIt", NULL
38006 };
38007
38008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38009 if (obj0) {
38010 ecode1 = SWIG_AsVal_int(obj0, &val1);
38011 if (!SWIG_IsOK(ecode1)) {
38012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38013 }
38014 arg1 = static_cast< int >(val1);
38015 }
38016 {
38017 PyThreadState* __tstate = wxPyBeginAllowThreads();
38018 wxValidator::SetBellOnError(arg1);
38019 wxPyEndAllowThreads(__tstate);
38020 if (PyErr_Occurred()) SWIG_fail;
38021 }
38022 resultobj = SWIG_Py_Void();
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38030 PyObject *obj;
38031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38032 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38033 return SWIG_Py_Void();
38034 }
38035
38036 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38037 return SWIG_Python_InitShadowInstance(args);
38038 }
38039
38040 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38041 PyObject *resultobj = 0;
38042 wxPyValidator *result = 0 ;
38043
38044 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38045 {
38046 PyThreadState* __tstate = wxPyBeginAllowThreads();
38047 result = (wxPyValidator *)new wxPyValidator();
38048 wxPyEndAllowThreads(__tstate);
38049 if (PyErr_Occurred()) SWIG_fail;
38050 }
38051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38052 return resultobj;
38053 fail:
38054 return NULL;
38055 }
38056
38057
38058 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38059 PyObject *resultobj = 0;
38060 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38061 PyObject *arg2 = (PyObject *) 0 ;
38062 PyObject *arg3 = (PyObject *) 0 ;
38063 int arg4 = (int) true ;
38064 void *argp1 = 0 ;
38065 int res1 = 0 ;
38066 int val4 ;
38067 int ecode4 = 0 ;
38068 PyObject * obj0 = 0 ;
38069 PyObject * obj1 = 0 ;
38070 PyObject * obj2 = 0 ;
38071 PyObject * obj3 = 0 ;
38072 char * kwnames[] = {
38073 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38074 };
38075
38076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38078 if (!SWIG_IsOK(res1)) {
38079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38080 }
38081 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38082 arg2 = obj1;
38083 arg3 = obj2;
38084 if (obj3) {
38085 ecode4 = SWIG_AsVal_int(obj3, &val4);
38086 if (!SWIG_IsOK(ecode4)) {
38087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38088 }
38089 arg4 = static_cast< int >(val4);
38090 }
38091 {
38092 PyThreadState* __tstate = wxPyBeginAllowThreads();
38093 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38094 wxPyEndAllowThreads(__tstate);
38095 if (PyErr_Occurred()) SWIG_fail;
38096 }
38097 resultobj = SWIG_Py_Void();
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38105 PyObject *obj;
38106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38107 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38108 return SWIG_Py_Void();
38109 }
38110
38111 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38112 return SWIG_Python_InitShadowInstance(args);
38113 }
38114
38115 SWIGINTERN int DefaultValidator_set(PyObject *) {
38116 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38117 return 1;
38118 }
38119
38120
38121 SWIGINTERN PyObject *DefaultValidator_get(void) {
38122 PyObject *pyobj = 0;
38123
38124 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38125 return pyobj;
38126 }
38127
38128
38129 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38130 PyObject *resultobj = 0;
38131 wxString const &arg1_defvalue = wxPyEmptyString ;
38132 wxString *arg1 = (wxString *) &arg1_defvalue ;
38133 long arg2 = (long) 0 ;
38134 wxMenu *result = 0 ;
38135 bool temp1 = false ;
38136 long val2 ;
38137 int ecode2 = 0 ;
38138 PyObject * obj0 = 0 ;
38139 PyObject * obj1 = 0 ;
38140 char * kwnames[] = {
38141 (char *) "title",(char *) "style", NULL
38142 };
38143
38144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38145 if (obj0) {
38146 {
38147 arg1 = wxString_in_helper(obj0);
38148 if (arg1 == NULL) SWIG_fail;
38149 temp1 = true;
38150 }
38151 }
38152 if (obj1) {
38153 ecode2 = SWIG_AsVal_long(obj1, &val2);
38154 if (!SWIG_IsOK(ecode2)) {
38155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38156 }
38157 arg2 = static_cast< long >(val2);
38158 }
38159 {
38160 if (!wxPyCheckForApp()) SWIG_fail;
38161 PyThreadState* __tstate = wxPyBeginAllowThreads();
38162 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38163 wxPyEndAllowThreads(__tstate);
38164 if (PyErr_Occurred()) SWIG_fail;
38165 }
38166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38167 {
38168 if (temp1)
38169 delete arg1;
38170 }
38171 return resultobj;
38172 fail:
38173 {
38174 if (temp1)
38175 delete arg1;
38176 }
38177 return NULL;
38178 }
38179
38180
38181 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38182 PyObject *resultobj = 0;
38183 wxMenu *arg1 = (wxMenu *) 0 ;
38184 int arg2 ;
38185 wxString *arg3 = 0 ;
38186 wxString const &arg4_defvalue = wxPyEmptyString ;
38187 wxString *arg4 = (wxString *) &arg4_defvalue ;
38188 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38189 wxMenuItem *result = 0 ;
38190 void *argp1 = 0 ;
38191 int res1 = 0 ;
38192 int val2 ;
38193 int ecode2 = 0 ;
38194 bool temp3 = false ;
38195 bool temp4 = false ;
38196 int val5 ;
38197 int ecode5 = 0 ;
38198 PyObject * obj0 = 0 ;
38199 PyObject * obj1 = 0 ;
38200 PyObject * obj2 = 0 ;
38201 PyObject * obj3 = 0 ;
38202 PyObject * obj4 = 0 ;
38203 char * kwnames[] = {
38204 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38205 };
38206
38207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38209 if (!SWIG_IsOK(res1)) {
38210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38211 }
38212 arg1 = reinterpret_cast< wxMenu * >(argp1);
38213 ecode2 = SWIG_AsVal_int(obj1, &val2);
38214 if (!SWIG_IsOK(ecode2)) {
38215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38216 }
38217 arg2 = static_cast< int >(val2);
38218 {
38219 arg3 = wxString_in_helper(obj2);
38220 if (arg3 == NULL) SWIG_fail;
38221 temp3 = true;
38222 }
38223 if (obj3) {
38224 {
38225 arg4 = wxString_in_helper(obj3);
38226 if (arg4 == NULL) SWIG_fail;
38227 temp4 = true;
38228 }
38229 }
38230 if (obj4) {
38231 ecode5 = SWIG_AsVal_int(obj4, &val5);
38232 if (!SWIG_IsOK(ecode5)) {
38233 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38234 }
38235 arg5 = static_cast< wxItemKind >(val5);
38236 }
38237 {
38238 PyThreadState* __tstate = wxPyBeginAllowThreads();
38239 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38240 wxPyEndAllowThreads(__tstate);
38241 if (PyErr_Occurred()) SWIG_fail;
38242 }
38243 {
38244 resultobj = wxPyMake_wxObject(result, (bool)0);
38245 }
38246 {
38247 if (temp3)
38248 delete arg3;
38249 }
38250 {
38251 if (temp4)
38252 delete arg4;
38253 }
38254 return resultobj;
38255 fail:
38256 {
38257 if (temp3)
38258 delete arg3;
38259 }
38260 {
38261 if (temp4)
38262 delete arg4;
38263 }
38264 return NULL;
38265 }
38266
38267
38268 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38269 PyObject *resultobj = 0;
38270 wxMenu *arg1 = (wxMenu *) 0 ;
38271 wxMenuItem *result = 0 ;
38272 void *argp1 = 0 ;
38273 int res1 = 0 ;
38274 PyObject *swig_obj[1] ;
38275
38276 if (!args) SWIG_fail;
38277 swig_obj[0] = args;
38278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38279 if (!SWIG_IsOK(res1)) {
38280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38281 }
38282 arg1 = reinterpret_cast< wxMenu * >(argp1);
38283 {
38284 PyThreadState* __tstate = wxPyBeginAllowThreads();
38285 result = (wxMenuItem *)(arg1)->AppendSeparator();
38286 wxPyEndAllowThreads(__tstate);
38287 if (PyErr_Occurred()) SWIG_fail;
38288 }
38289 {
38290 resultobj = wxPyMake_wxObject(result, (bool)0);
38291 }
38292 return resultobj;
38293 fail:
38294 return NULL;
38295 }
38296
38297
38298 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38299 PyObject *resultobj = 0;
38300 wxMenu *arg1 = (wxMenu *) 0 ;
38301 int arg2 ;
38302 wxString *arg3 = 0 ;
38303 wxString const &arg4_defvalue = wxPyEmptyString ;
38304 wxString *arg4 = (wxString *) &arg4_defvalue ;
38305 wxMenuItem *result = 0 ;
38306 void *argp1 = 0 ;
38307 int res1 = 0 ;
38308 int val2 ;
38309 int ecode2 = 0 ;
38310 bool temp3 = false ;
38311 bool temp4 = false ;
38312 PyObject * obj0 = 0 ;
38313 PyObject * obj1 = 0 ;
38314 PyObject * obj2 = 0 ;
38315 PyObject * obj3 = 0 ;
38316 char * kwnames[] = {
38317 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38318 };
38319
38320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38322 if (!SWIG_IsOK(res1)) {
38323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38324 }
38325 arg1 = reinterpret_cast< wxMenu * >(argp1);
38326 ecode2 = SWIG_AsVal_int(obj1, &val2);
38327 if (!SWIG_IsOK(ecode2)) {
38328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38329 }
38330 arg2 = static_cast< int >(val2);
38331 {
38332 arg3 = wxString_in_helper(obj2);
38333 if (arg3 == NULL) SWIG_fail;
38334 temp3 = true;
38335 }
38336 if (obj3) {
38337 {
38338 arg4 = wxString_in_helper(obj3);
38339 if (arg4 == NULL) SWIG_fail;
38340 temp4 = true;
38341 }
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 {
38350 resultobj = wxPyMake_wxObject(result, (bool)0);
38351 }
38352 {
38353 if (temp3)
38354 delete arg3;
38355 }
38356 {
38357 if (temp4)
38358 delete arg4;
38359 }
38360 return resultobj;
38361 fail:
38362 {
38363 if (temp3)
38364 delete arg3;
38365 }
38366 {
38367 if (temp4)
38368 delete arg4;
38369 }
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxMenu *arg1 = (wxMenu *) 0 ;
38377 int arg2 ;
38378 wxString *arg3 = 0 ;
38379 wxString const &arg4_defvalue = wxPyEmptyString ;
38380 wxString *arg4 = (wxString *) &arg4_defvalue ;
38381 wxMenuItem *result = 0 ;
38382 void *argp1 = 0 ;
38383 int res1 = 0 ;
38384 int val2 ;
38385 int ecode2 = 0 ;
38386 bool temp3 = false ;
38387 bool temp4 = false ;
38388 PyObject * obj0 = 0 ;
38389 PyObject * obj1 = 0 ;
38390 PyObject * obj2 = 0 ;
38391 PyObject * obj3 = 0 ;
38392 char * kwnames[] = {
38393 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38394 };
38395
38396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38398 if (!SWIG_IsOK(res1)) {
38399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38400 }
38401 arg1 = reinterpret_cast< wxMenu * >(argp1);
38402 ecode2 = SWIG_AsVal_int(obj1, &val2);
38403 if (!SWIG_IsOK(ecode2)) {
38404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38405 }
38406 arg2 = static_cast< int >(val2);
38407 {
38408 arg3 = wxString_in_helper(obj2);
38409 if (arg3 == NULL) SWIG_fail;
38410 temp3 = true;
38411 }
38412 if (obj3) {
38413 {
38414 arg4 = wxString_in_helper(obj3);
38415 if (arg4 == NULL) SWIG_fail;
38416 temp4 = true;
38417 }
38418 }
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 {
38426 resultobj = wxPyMake_wxObject(result, (bool)0);
38427 }
38428 {
38429 if (temp3)
38430 delete arg3;
38431 }
38432 {
38433 if (temp4)
38434 delete arg4;
38435 }
38436 return resultobj;
38437 fail:
38438 {
38439 if (temp3)
38440 delete arg3;
38441 }
38442 {
38443 if (temp4)
38444 delete arg4;
38445 }
38446 return NULL;
38447 }
38448
38449
38450 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38451 PyObject *resultobj = 0;
38452 wxMenu *arg1 = (wxMenu *) 0 ;
38453 int arg2 ;
38454 wxString *arg3 = 0 ;
38455 wxMenu *arg4 = (wxMenu *) 0 ;
38456 wxString const &arg5_defvalue = wxPyEmptyString ;
38457 wxString *arg5 = (wxString *) &arg5_defvalue ;
38458 wxMenuItem *result = 0 ;
38459 void *argp1 = 0 ;
38460 int res1 = 0 ;
38461 int val2 ;
38462 int ecode2 = 0 ;
38463 bool temp3 = false ;
38464 void *argp4 = 0 ;
38465 int res4 = 0 ;
38466 bool temp5 = false ;
38467 PyObject * obj0 = 0 ;
38468 PyObject * obj1 = 0 ;
38469 PyObject * obj2 = 0 ;
38470 PyObject * obj3 = 0 ;
38471 PyObject * obj4 = 0 ;
38472 char * kwnames[] = {
38473 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38474 };
38475
38476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38478 if (!SWIG_IsOK(res1)) {
38479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38480 }
38481 arg1 = reinterpret_cast< wxMenu * >(argp1);
38482 ecode2 = SWIG_AsVal_int(obj1, &val2);
38483 if (!SWIG_IsOK(ecode2)) {
38484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38485 }
38486 arg2 = static_cast< int >(val2);
38487 {
38488 arg3 = wxString_in_helper(obj2);
38489 if (arg3 == NULL) SWIG_fail;
38490 temp3 = true;
38491 }
38492 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38493 if (!SWIG_IsOK(res4)) {
38494 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38495 }
38496 arg4 = reinterpret_cast< wxMenu * >(argp4);
38497 if (obj4) {
38498 {
38499 arg5 = wxString_in_helper(obj4);
38500 if (arg5 == NULL) SWIG_fail;
38501 temp5 = true;
38502 }
38503 }
38504 {
38505 PyThreadState* __tstate = wxPyBeginAllowThreads();
38506 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38507 wxPyEndAllowThreads(__tstate);
38508 if (PyErr_Occurred()) SWIG_fail;
38509 }
38510 {
38511 resultobj = wxPyMake_wxObject(result, (bool)0);
38512 }
38513 {
38514 if (temp3)
38515 delete arg3;
38516 }
38517 {
38518 if (temp5)
38519 delete arg5;
38520 }
38521 return resultobj;
38522 fail:
38523 {
38524 if (temp3)
38525 delete arg3;
38526 }
38527 {
38528 if (temp5)
38529 delete arg5;
38530 }
38531 return NULL;
38532 }
38533
38534
38535 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38536 PyObject *resultobj = 0;
38537 wxMenu *arg1 = (wxMenu *) 0 ;
38538 wxMenu *arg2 = (wxMenu *) 0 ;
38539 wxString *arg3 = 0 ;
38540 wxString const &arg4_defvalue = wxPyEmptyString ;
38541 wxString *arg4 = (wxString *) &arg4_defvalue ;
38542 wxMenuItem *result = 0 ;
38543 void *argp1 = 0 ;
38544 int res1 = 0 ;
38545 void *argp2 = 0 ;
38546 int res2 = 0 ;
38547 bool temp3 = false ;
38548 bool temp4 = false ;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 PyObject * obj2 = 0 ;
38552 PyObject * obj3 = 0 ;
38553 char * kwnames[] = {
38554 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38555 };
38556
38557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38559 if (!SWIG_IsOK(res1)) {
38560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38561 }
38562 arg1 = reinterpret_cast< wxMenu * >(argp1);
38563 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38564 if (!SWIG_IsOK(res2)) {
38565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38566 }
38567 arg2 = reinterpret_cast< wxMenu * >(argp2);
38568 {
38569 arg3 = wxString_in_helper(obj2);
38570 if (arg3 == NULL) SWIG_fail;
38571 temp3 = true;
38572 }
38573 if (obj3) {
38574 {
38575 arg4 = wxString_in_helper(obj3);
38576 if (arg4 == NULL) SWIG_fail;
38577 temp4 = true;
38578 }
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 {
38587 resultobj = wxPyMake_wxObject(result, (bool)0);
38588 }
38589 {
38590 if (temp3)
38591 delete arg3;
38592 }
38593 {
38594 if (temp4)
38595 delete arg4;
38596 }
38597 return resultobj;
38598 fail:
38599 {
38600 if (temp3)
38601 delete arg3;
38602 }
38603 {
38604 if (temp4)
38605 delete arg4;
38606 }
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = 0;
38613 wxMenu *arg1 = (wxMenu *) 0 ;
38614 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38615 wxMenuItem *result = 0 ;
38616 void *argp1 = 0 ;
38617 int res1 = 0 ;
38618 int res2 = 0 ;
38619 PyObject * obj0 = 0 ;
38620 PyObject * obj1 = 0 ;
38621 char * kwnames[] = {
38622 (char *) "self",(char *) "item", NULL
38623 };
38624
38625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38627 if (!SWIG_IsOK(res1)) {
38628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38629 }
38630 arg1 = reinterpret_cast< wxMenu * >(argp1);
38631 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38632 if (!SWIG_IsOK(res2)) {
38633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38634 }
38635 {
38636 PyThreadState* __tstate = wxPyBeginAllowThreads();
38637 result = (wxMenuItem *)(arg1)->Append(arg2);
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 {
38642 resultobj = wxPyMake_wxObject(result, (bool)0);
38643 }
38644 return resultobj;
38645 fail:
38646 return NULL;
38647 }
38648
38649
38650 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38651 PyObject *resultobj = 0;
38652 wxMenu *arg1 = (wxMenu *) 0 ;
38653 size_t arg2 ;
38654 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38655 wxMenuItem *result = 0 ;
38656 void *argp1 = 0 ;
38657 int res1 = 0 ;
38658 size_t val2 ;
38659 int ecode2 = 0 ;
38660 int res3 = 0 ;
38661 PyObject * obj0 = 0 ;
38662 PyObject * obj1 = 0 ;
38663 PyObject * obj2 = 0 ;
38664 char * kwnames[] = {
38665 (char *) "self",(char *) "pos",(char *) "item", NULL
38666 };
38667
38668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38670 if (!SWIG_IsOK(res1)) {
38671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38672 }
38673 arg1 = reinterpret_cast< wxMenu * >(argp1);
38674 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38675 if (!SWIG_IsOK(ecode2)) {
38676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38677 }
38678 arg2 = static_cast< size_t >(val2);
38679 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38680 if (!SWIG_IsOK(res3)) {
38681 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38682 }
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 {
38690 resultobj = wxPyMake_wxObject(result, (bool)0);
38691 }
38692 return resultobj;
38693 fail:
38694 return NULL;
38695 }
38696
38697
38698 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38699 PyObject *resultobj = 0;
38700 wxMenu *arg1 = (wxMenu *) 0 ;
38701 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38702 wxMenuItem *result = 0 ;
38703 void *argp1 = 0 ;
38704 int res1 = 0 ;
38705 int res2 = 0 ;
38706 PyObject * obj0 = 0 ;
38707 PyObject * obj1 = 0 ;
38708 char * kwnames[] = {
38709 (char *) "self",(char *) "item", NULL
38710 };
38711
38712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38714 if (!SWIG_IsOK(res1)) {
38715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38716 }
38717 arg1 = reinterpret_cast< wxMenu * >(argp1);
38718 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38719 if (!SWIG_IsOK(res2)) {
38720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38721 }
38722 {
38723 PyThreadState* __tstate = wxPyBeginAllowThreads();
38724 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38725 wxPyEndAllowThreads(__tstate);
38726 if (PyErr_Occurred()) SWIG_fail;
38727 }
38728 {
38729 resultobj = wxPyMake_wxObject(result, (bool)0);
38730 }
38731 return resultobj;
38732 fail:
38733 return NULL;
38734 }
38735
38736
38737 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38738 PyObject *resultobj = 0;
38739 wxMenu *arg1 = (wxMenu *) 0 ;
38740 void *argp1 = 0 ;
38741 int res1 = 0 ;
38742 PyObject *swig_obj[1] ;
38743
38744 if (!args) SWIG_fail;
38745 swig_obj[0] = args;
38746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38747 if (!SWIG_IsOK(res1)) {
38748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38749 }
38750 arg1 = reinterpret_cast< wxMenu * >(argp1);
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 (arg1)->Break();
38754 wxPyEndAllowThreads(__tstate);
38755 if (PyErr_Occurred()) SWIG_fail;
38756 }
38757 resultobj = SWIG_Py_Void();
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38765 PyObject *resultobj = 0;
38766 wxMenu *arg1 = (wxMenu *) 0 ;
38767 size_t arg2 ;
38768 int arg3 ;
38769 wxString *arg4 = 0 ;
38770 wxString const &arg5_defvalue = wxPyEmptyString ;
38771 wxString *arg5 = (wxString *) &arg5_defvalue ;
38772 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38773 wxMenuItem *result = 0 ;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 size_t val2 ;
38777 int ecode2 = 0 ;
38778 int val3 ;
38779 int ecode3 = 0 ;
38780 bool temp4 = false ;
38781 bool temp5 = false ;
38782 int val6 ;
38783 int ecode6 = 0 ;
38784 PyObject * obj0 = 0 ;
38785 PyObject * obj1 = 0 ;
38786 PyObject * obj2 = 0 ;
38787 PyObject * obj3 = 0 ;
38788 PyObject * obj4 = 0 ;
38789 PyObject * obj5 = 0 ;
38790 char * kwnames[] = {
38791 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38792 };
38793
38794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38796 if (!SWIG_IsOK(res1)) {
38797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38798 }
38799 arg1 = reinterpret_cast< wxMenu * >(argp1);
38800 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38801 if (!SWIG_IsOK(ecode2)) {
38802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38803 }
38804 arg2 = static_cast< size_t >(val2);
38805 ecode3 = SWIG_AsVal_int(obj2, &val3);
38806 if (!SWIG_IsOK(ecode3)) {
38807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38808 }
38809 arg3 = static_cast< int >(val3);
38810 {
38811 arg4 = wxString_in_helper(obj3);
38812 if (arg4 == NULL) SWIG_fail;
38813 temp4 = true;
38814 }
38815 if (obj4) {
38816 {
38817 arg5 = wxString_in_helper(obj4);
38818 if (arg5 == NULL) SWIG_fail;
38819 temp5 = true;
38820 }
38821 }
38822 if (obj5) {
38823 ecode6 = SWIG_AsVal_int(obj5, &val6);
38824 if (!SWIG_IsOK(ecode6)) {
38825 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38826 }
38827 arg6 = static_cast< wxItemKind >(val6);
38828 }
38829 {
38830 PyThreadState* __tstate = wxPyBeginAllowThreads();
38831 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38832 wxPyEndAllowThreads(__tstate);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 }
38835 {
38836 resultobj = wxPyMake_wxObject(result, (bool)0);
38837 }
38838 {
38839 if (temp4)
38840 delete arg4;
38841 }
38842 {
38843 if (temp5)
38844 delete arg5;
38845 }
38846 return resultobj;
38847 fail:
38848 {
38849 if (temp4)
38850 delete arg4;
38851 }
38852 {
38853 if (temp5)
38854 delete arg5;
38855 }
38856 return NULL;
38857 }
38858
38859
38860 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38861 PyObject *resultobj = 0;
38862 wxMenu *arg1 = (wxMenu *) 0 ;
38863 size_t arg2 ;
38864 wxMenuItem *result = 0 ;
38865 void *argp1 = 0 ;
38866 int res1 = 0 ;
38867 size_t val2 ;
38868 int ecode2 = 0 ;
38869 PyObject * obj0 = 0 ;
38870 PyObject * obj1 = 0 ;
38871 char * kwnames[] = {
38872 (char *) "self",(char *) "pos", NULL
38873 };
38874
38875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38877 if (!SWIG_IsOK(res1)) {
38878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38879 }
38880 arg1 = reinterpret_cast< wxMenu * >(argp1);
38881 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38882 if (!SWIG_IsOK(ecode2)) {
38883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38884 }
38885 arg2 = static_cast< size_t >(val2);
38886 {
38887 PyThreadState* __tstate = wxPyBeginAllowThreads();
38888 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38889 wxPyEndAllowThreads(__tstate);
38890 if (PyErr_Occurred()) SWIG_fail;
38891 }
38892 {
38893 resultobj = wxPyMake_wxObject(result, (bool)0);
38894 }
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj = 0;
38903 wxMenu *arg1 = (wxMenu *) 0 ;
38904 size_t arg2 ;
38905 int arg3 ;
38906 wxString *arg4 = 0 ;
38907 wxString const &arg5_defvalue = wxPyEmptyString ;
38908 wxString *arg5 = (wxString *) &arg5_defvalue ;
38909 wxMenuItem *result = 0 ;
38910 void *argp1 = 0 ;
38911 int res1 = 0 ;
38912 size_t val2 ;
38913 int ecode2 = 0 ;
38914 int val3 ;
38915 int ecode3 = 0 ;
38916 bool temp4 = false ;
38917 bool temp5 = false ;
38918 PyObject * obj0 = 0 ;
38919 PyObject * obj1 = 0 ;
38920 PyObject * obj2 = 0 ;
38921 PyObject * obj3 = 0 ;
38922 PyObject * obj4 = 0 ;
38923 char * kwnames[] = {
38924 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38925 };
38926
38927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38929 if (!SWIG_IsOK(res1)) {
38930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38931 }
38932 arg1 = reinterpret_cast< wxMenu * >(argp1);
38933 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38934 if (!SWIG_IsOK(ecode2)) {
38935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38936 }
38937 arg2 = static_cast< size_t >(val2);
38938 ecode3 = SWIG_AsVal_int(obj2, &val3);
38939 if (!SWIG_IsOK(ecode3)) {
38940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38941 }
38942 arg3 = static_cast< int >(val3);
38943 {
38944 arg4 = wxString_in_helper(obj3);
38945 if (arg4 == NULL) SWIG_fail;
38946 temp4 = true;
38947 }
38948 if (obj4) {
38949 {
38950 arg5 = wxString_in_helper(obj4);
38951 if (arg5 == NULL) SWIG_fail;
38952 temp5 = true;
38953 }
38954 }
38955 {
38956 PyThreadState* __tstate = wxPyBeginAllowThreads();
38957 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38958 wxPyEndAllowThreads(__tstate);
38959 if (PyErr_Occurred()) SWIG_fail;
38960 }
38961 {
38962 resultobj = wxPyMake_wxObject(result, (bool)0);
38963 }
38964 {
38965 if (temp4)
38966 delete arg4;
38967 }
38968 {
38969 if (temp5)
38970 delete arg5;
38971 }
38972 return resultobj;
38973 fail:
38974 {
38975 if (temp4)
38976 delete arg4;
38977 }
38978 {
38979 if (temp5)
38980 delete arg5;
38981 }
38982 return NULL;
38983 }
38984
38985
38986 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38987 PyObject *resultobj = 0;
38988 wxMenu *arg1 = (wxMenu *) 0 ;
38989 size_t arg2 ;
38990 int arg3 ;
38991 wxString *arg4 = 0 ;
38992 wxString const &arg5_defvalue = wxPyEmptyString ;
38993 wxString *arg5 = (wxString *) &arg5_defvalue ;
38994 wxMenuItem *result = 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 size_t val2 ;
38998 int ecode2 = 0 ;
38999 int val3 ;
39000 int ecode3 = 0 ;
39001 bool temp4 = false ;
39002 bool temp5 = false ;
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 *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39010 };
39011
39012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",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_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39016 }
39017 arg1 = reinterpret_cast< wxMenu * >(argp1);
39018 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39019 if (!SWIG_IsOK(ecode2)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39021 }
39022 arg2 = static_cast< size_t >(val2);
39023 ecode3 = SWIG_AsVal_int(obj2, &val3);
39024 if (!SWIG_IsOK(ecode3)) {
39025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39026 }
39027 arg3 = static_cast< int >(val3);
39028 {
39029 arg4 = wxString_in_helper(obj3);
39030 if (arg4 == NULL) SWIG_fail;
39031 temp4 = true;
39032 }
39033 if (obj4) {
39034 {
39035 arg5 = wxString_in_helper(obj4);
39036 if (arg5 == NULL) SWIG_fail;
39037 temp5 = true;
39038 }
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 {
39047 resultobj = wxPyMake_wxObject(result, (bool)0);
39048 }
39049 {
39050 if (temp4)
39051 delete arg4;
39052 }
39053 {
39054 if (temp5)
39055 delete arg5;
39056 }
39057 return resultobj;
39058 fail:
39059 {
39060 if (temp4)
39061 delete arg4;
39062 }
39063 {
39064 if (temp5)
39065 delete arg5;
39066 }
39067 return NULL;
39068 }
39069
39070
39071 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj = 0;
39073 wxMenu *arg1 = (wxMenu *) 0 ;
39074 size_t arg2 ;
39075 int arg3 ;
39076 wxString *arg4 = 0 ;
39077 wxMenu *arg5 = (wxMenu *) 0 ;
39078 wxString const &arg6_defvalue = wxPyEmptyString ;
39079 wxString *arg6 = (wxString *) &arg6_defvalue ;
39080 wxMenuItem *result = 0 ;
39081 void *argp1 = 0 ;
39082 int res1 = 0 ;
39083 size_t val2 ;
39084 int ecode2 = 0 ;
39085 int val3 ;
39086 int ecode3 = 0 ;
39087 bool temp4 = false ;
39088 void *argp5 = 0 ;
39089 int res5 = 0 ;
39090 bool temp6 = false ;
39091 PyObject * obj0 = 0 ;
39092 PyObject * obj1 = 0 ;
39093 PyObject * obj2 = 0 ;
39094 PyObject * obj3 = 0 ;
39095 PyObject * obj4 = 0 ;
39096 PyObject * obj5 = 0 ;
39097 char * kwnames[] = {
39098 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39099 };
39100
39101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39103 if (!SWIG_IsOK(res1)) {
39104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39105 }
39106 arg1 = reinterpret_cast< wxMenu * >(argp1);
39107 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39108 if (!SWIG_IsOK(ecode2)) {
39109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39110 }
39111 arg2 = static_cast< size_t >(val2);
39112 ecode3 = SWIG_AsVal_int(obj2, &val3);
39113 if (!SWIG_IsOK(ecode3)) {
39114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39115 }
39116 arg3 = static_cast< int >(val3);
39117 {
39118 arg4 = wxString_in_helper(obj3);
39119 if (arg4 == NULL) SWIG_fail;
39120 temp4 = true;
39121 }
39122 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39123 if (!SWIG_IsOK(res5)) {
39124 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39125 }
39126 arg5 = reinterpret_cast< wxMenu * >(argp5);
39127 if (obj5) {
39128 {
39129 arg6 = wxString_in_helper(obj5);
39130 if (arg6 == NULL) SWIG_fail;
39131 temp6 = true;
39132 }
39133 }
39134 {
39135 PyThreadState* __tstate = wxPyBeginAllowThreads();
39136 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39137 wxPyEndAllowThreads(__tstate);
39138 if (PyErr_Occurred()) SWIG_fail;
39139 }
39140 {
39141 resultobj = wxPyMake_wxObject(result, (bool)0);
39142 }
39143 {
39144 if (temp4)
39145 delete arg4;
39146 }
39147 {
39148 if (temp6)
39149 delete arg6;
39150 }
39151 return resultobj;
39152 fail:
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 {
39158 if (temp6)
39159 delete arg6;
39160 }
39161 return NULL;
39162 }
39163
39164
39165 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39166 PyObject *resultobj = 0;
39167 wxMenu *arg1 = (wxMenu *) 0 ;
39168 int arg2 ;
39169 wxString *arg3 = 0 ;
39170 wxString const &arg4_defvalue = wxPyEmptyString ;
39171 wxString *arg4 = (wxString *) &arg4_defvalue ;
39172 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39173 wxMenuItem *result = 0 ;
39174 void *argp1 = 0 ;
39175 int res1 = 0 ;
39176 int val2 ;
39177 int ecode2 = 0 ;
39178 bool temp3 = false ;
39179 bool temp4 = false ;
39180 int val5 ;
39181 int ecode5 = 0 ;
39182 PyObject * obj0 = 0 ;
39183 PyObject * obj1 = 0 ;
39184 PyObject * obj2 = 0 ;
39185 PyObject * obj3 = 0 ;
39186 PyObject * obj4 = 0 ;
39187 char * kwnames[] = {
39188 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39189 };
39190
39191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39193 if (!SWIG_IsOK(res1)) {
39194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39195 }
39196 arg1 = reinterpret_cast< wxMenu * >(argp1);
39197 ecode2 = SWIG_AsVal_int(obj1, &val2);
39198 if (!SWIG_IsOK(ecode2)) {
39199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39200 }
39201 arg2 = static_cast< int >(val2);
39202 {
39203 arg3 = wxString_in_helper(obj2);
39204 if (arg3 == NULL) SWIG_fail;
39205 temp3 = true;
39206 }
39207 if (obj3) {
39208 {
39209 arg4 = wxString_in_helper(obj3);
39210 if (arg4 == NULL) SWIG_fail;
39211 temp4 = true;
39212 }
39213 }
39214 if (obj4) {
39215 ecode5 = SWIG_AsVal_int(obj4, &val5);
39216 if (!SWIG_IsOK(ecode5)) {
39217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39218 }
39219 arg5 = static_cast< wxItemKind >(val5);
39220 }
39221 {
39222 PyThreadState* __tstate = wxPyBeginAllowThreads();
39223 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39224 wxPyEndAllowThreads(__tstate);
39225 if (PyErr_Occurred()) SWIG_fail;
39226 }
39227 {
39228 resultobj = wxPyMake_wxObject(result, (bool)0);
39229 }
39230 {
39231 if (temp3)
39232 delete arg3;
39233 }
39234 {
39235 if (temp4)
39236 delete arg4;
39237 }
39238 return resultobj;
39239 fail:
39240 {
39241 if (temp3)
39242 delete arg3;
39243 }
39244 {
39245 if (temp4)
39246 delete arg4;
39247 }
39248 return NULL;
39249 }
39250
39251
39252 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39253 PyObject *resultobj = 0;
39254 wxMenu *arg1 = (wxMenu *) 0 ;
39255 wxMenuItem *result = 0 ;
39256 void *argp1 = 0 ;
39257 int res1 = 0 ;
39258 PyObject *swig_obj[1] ;
39259
39260 if (!args) SWIG_fail;
39261 swig_obj[0] = args;
39262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39263 if (!SWIG_IsOK(res1)) {
39264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39265 }
39266 arg1 = reinterpret_cast< wxMenu * >(argp1);
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 result = (wxMenuItem *)(arg1)->PrependSeparator();
39270 wxPyEndAllowThreads(__tstate);
39271 if (PyErr_Occurred()) SWIG_fail;
39272 }
39273 {
39274 resultobj = wxPyMake_wxObject(result, (bool)0);
39275 }
39276 return resultobj;
39277 fail:
39278 return NULL;
39279 }
39280
39281
39282 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39283 PyObject *resultobj = 0;
39284 wxMenu *arg1 = (wxMenu *) 0 ;
39285 int arg2 ;
39286 wxString *arg3 = 0 ;
39287 wxString const &arg4_defvalue = wxPyEmptyString ;
39288 wxString *arg4 = (wxString *) &arg4_defvalue ;
39289 wxMenuItem *result = 0 ;
39290 void *argp1 = 0 ;
39291 int res1 = 0 ;
39292 int val2 ;
39293 int ecode2 = 0 ;
39294 bool temp3 = false ;
39295 bool temp4 = false ;
39296 PyObject * obj0 = 0 ;
39297 PyObject * obj1 = 0 ;
39298 PyObject * obj2 = 0 ;
39299 PyObject * obj3 = 0 ;
39300 char * kwnames[] = {
39301 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39302 };
39303
39304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39306 if (!SWIG_IsOK(res1)) {
39307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39308 }
39309 arg1 = reinterpret_cast< wxMenu * >(argp1);
39310 ecode2 = SWIG_AsVal_int(obj1, &val2);
39311 if (!SWIG_IsOK(ecode2)) {
39312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39313 }
39314 arg2 = static_cast< int >(val2);
39315 {
39316 arg3 = wxString_in_helper(obj2);
39317 if (arg3 == NULL) SWIG_fail;
39318 temp3 = true;
39319 }
39320 if (obj3) {
39321 {
39322 arg4 = wxString_in_helper(obj3);
39323 if (arg4 == NULL) SWIG_fail;
39324 temp4 = true;
39325 }
39326 }
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 {
39334 resultobj = wxPyMake_wxObject(result, (bool)0);
39335 }
39336 {
39337 if (temp3)
39338 delete arg3;
39339 }
39340 {
39341 if (temp4)
39342 delete arg4;
39343 }
39344 return resultobj;
39345 fail:
39346 {
39347 if (temp3)
39348 delete arg3;
39349 }
39350 {
39351 if (temp4)
39352 delete arg4;
39353 }
39354 return NULL;
39355 }
39356
39357
39358 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39359 PyObject *resultobj = 0;
39360 wxMenu *arg1 = (wxMenu *) 0 ;
39361 int arg2 ;
39362 wxString *arg3 = 0 ;
39363 wxString const &arg4_defvalue = wxPyEmptyString ;
39364 wxString *arg4 = (wxString *) &arg4_defvalue ;
39365 wxMenuItem *result = 0 ;
39366 void *argp1 = 0 ;
39367 int res1 = 0 ;
39368 int val2 ;
39369 int ecode2 = 0 ;
39370 bool temp3 = false ;
39371 bool temp4 = false ;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 PyObject * obj2 = 0 ;
39375 PyObject * obj3 = 0 ;
39376 char * kwnames[] = {
39377 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39378 };
39379
39380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39382 if (!SWIG_IsOK(res1)) {
39383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39384 }
39385 arg1 = reinterpret_cast< wxMenu * >(argp1);
39386 ecode2 = SWIG_AsVal_int(obj1, &val2);
39387 if (!SWIG_IsOK(ecode2)) {
39388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39389 }
39390 arg2 = static_cast< int >(val2);
39391 {
39392 arg3 = wxString_in_helper(obj2);
39393 if (arg3 == NULL) SWIG_fail;
39394 temp3 = true;
39395 }
39396 if (obj3) {
39397 {
39398 arg4 = wxString_in_helper(obj3);
39399 if (arg4 == NULL) SWIG_fail;
39400 temp4 = true;
39401 }
39402 }
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 {
39410 resultobj = wxPyMake_wxObject(result, (bool)0);
39411 }
39412 {
39413 if (temp3)
39414 delete arg3;
39415 }
39416 {
39417 if (temp4)
39418 delete arg4;
39419 }
39420 return resultobj;
39421 fail:
39422 {
39423 if (temp3)
39424 delete arg3;
39425 }
39426 {
39427 if (temp4)
39428 delete arg4;
39429 }
39430 return NULL;
39431 }
39432
39433
39434 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39435 PyObject *resultobj = 0;
39436 wxMenu *arg1 = (wxMenu *) 0 ;
39437 int arg2 ;
39438 wxString *arg3 = 0 ;
39439 wxMenu *arg4 = (wxMenu *) 0 ;
39440 wxString const &arg5_defvalue = wxPyEmptyString ;
39441 wxString *arg5 = (wxString *) &arg5_defvalue ;
39442 wxMenuItem *result = 0 ;
39443 void *argp1 = 0 ;
39444 int res1 = 0 ;
39445 int val2 ;
39446 int ecode2 = 0 ;
39447 bool temp3 = false ;
39448 void *argp4 = 0 ;
39449 int res4 = 0 ;
39450 bool temp5 = false ;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 PyObject * obj2 = 0 ;
39454 PyObject * obj3 = 0 ;
39455 PyObject * obj4 = 0 ;
39456 char * kwnames[] = {
39457 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39458 };
39459
39460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39462 if (!SWIG_IsOK(res1)) {
39463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39464 }
39465 arg1 = reinterpret_cast< wxMenu * >(argp1);
39466 ecode2 = SWIG_AsVal_int(obj1, &val2);
39467 if (!SWIG_IsOK(ecode2)) {
39468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39469 }
39470 arg2 = static_cast< int >(val2);
39471 {
39472 arg3 = wxString_in_helper(obj2);
39473 if (arg3 == NULL) SWIG_fail;
39474 temp3 = true;
39475 }
39476 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39477 if (!SWIG_IsOK(res4)) {
39478 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39479 }
39480 arg4 = reinterpret_cast< wxMenu * >(argp4);
39481 if (obj4) {
39482 {
39483 arg5 = wxString_in_helper(obj4);
39484 if (arg5 == NULL) SWIG_fail;
39485 temp5 = true;
39486 }
39487 }
39488 {
39489 PyThreadState* __tstate = wxPyBeginAllowThreads();
39490 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39491 wxPyEndAllowThreads(__tstate);
39492 if (PyErr_Occurred()) SWIG_fail;
39493 }
39494 {
39495 resultobj = wxPyMake_wxObject(result, (bool)0);
39496 }
39497 {
39498 if (temp3)
39499 delete arg3;
39500 }
39501 {
39502 if (temp5)
39503 delete arg5;
39504 }
39505 return resultobj;
39506 fail:
39507 {
39508 if (temp3)
39509 delete arg3;
39510 }
39511 {
39512 if (temp5)
39513 delete arg5;
39514 }
39515 return NULL;
39516 }
39517
39518
39519 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39520 PyObject *resultobj = 0;
39521 wxMenu *arg1 = (wxMenu *) 0 ;
39522 int arg2 ;
39523 wxMenuItem *result = 0 ;
39524 void *argp1 = 0 ;
39525 int res1 = 0 ;
39526 int val2 ;
39527 int ecode2 = 0 ;
39528 PyObject * obj0 = 0 ;
39529 PyObject * obj1 = 0 ;
39530 char * kwnames[] = {
39531 (char *) "self",(char *) "id", NULL
39532 };
39533
39534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39536 if (!SWIG_IsOK(res1)) {
39537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39538 }
39539 arg1 = reinterpret_cast< wxMenu * >(argp1);
39540 ecode2 = SWIG_AsVal_int(obj1, &val2);
39541 if (!SWIG_IsOK(ecode2)) {
39542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39543 }
39544 arg2 = static_cast< int >(val2);
39545 {
39546 PyThreadState* __tstate = wxPyBeginAllowThreads();
39547 result = (wxMenuItem *)(arg1)->Remove(arg2);
39548 wxPyEndAllowThreads(__tstate);
39549 if (PyErr_Occurred()) SWIG_fail;
39550 }
39551 {
39552 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39553 }
39554 return resultobj;
39555 fail:
39556 return NULL;
39557 }
39558
39559
39560 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39561 PyObject *resultobj = 0;
39562 wxMenu *arg1 = (wxMenu *) 0 ;
39563 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39564 wxMenuItem *result = 0 ;
39565 void *argp1 = 0 ;
39566 int res1 = 0 ;
39567 void *argp2 = 0 ;
39568 int res2 = 0 ;
39569 PyObject * obj0 = 0 ;
39570 PyObject * obj1 = 0 ;
39571 char * kwnames[] = {
39572 (char *) "self",(char *) "item", NULL
39573 };
39574
39575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39577 if (!SWIG_IsOK(res1)) {
39578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39579 }
39580 arg1 = reinterpret_cast< wxMenu * >(argp1);
39581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39582 if (!SWIG_IsOK(res2)) {
39583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39584 }
39585 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39586 {
39587 PyThreadState* __tstate = wxPyBeginAllowThreads();
39588 result = (wxMenuItem *)(arg1)->Remove(arg2);
39589 wxPyEndAllowThreads(__tstate);
39590 if (PyErr_Occurred()) SWIG_fail;
39591 }
39592 {
39593 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39594 }
39595 return resultobj;
39596 fail:
39597 return NULL;
39598 }
39599
39600
39601 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39602 PyObject *resultobj = 0;
39603 wxMenu *arg1 = (wxMenu *) 0 ;
39604 int arg2 ;
39605 bool result;
39606 void *argp1 = 0 ;
39607 int res1 = 0 ;
39608 int val2 ;
39609 int ecode2 = 0 ;
39610 PyObject * obj0 = 0 ;
39611 PyObject * obj1 = 0 ;
39612 char * kwnames[] = {
39613 (char *) "self",(char *) "id", NULL
39614 };
39615
39616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39618 if (!SWIG_IsOK(res1)) {
39619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39620 }
39621 arg1 = reinterpret_cast< wxMenu * >(argp1);
39622 ecode2 = SWIG_AsVal_int(obj1, &val2);
39623 if (!SWIG_IsOK(ecode2)) {
39624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39625 }
39626 arg2 = static_cast< int >(val2);
39627 {
39628 PyThreadState* __tstate = wxPyBeginAllowThreads();
39629 result = (bool)(arg1)->Delete(arg2);
39630 wxPyEndAllowThreads(__tstate);
39631 if (PyErr_Occurred()) SWIG_fail;
39632 }
39633 {
39634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39635 }
39636 return resultobj;
39637 fail:
39638 return NULL;
39639 }
39640
39641
39642 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39643 PyObject *resultobj = 0;
39644 wxMenu *arg1 = (wxMenu *) 0 ;
39645 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39646 bool result;
39647 void *argp1 = 0 ;
39648 int res1 = 0 ;
39649 void *argp2 = 0 ;
39650 int res2 = 0 ;
39651 PyObject * obj0 = 0 ;
39652 PyObject * obj1 = 0 ;
39653 char * kwnames[] = {
39654 (char *) "self",(char *) "item", NULL
39655 };
39656
39657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39659 if (!SWIG_IsOK(res1)) {
39660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39661 }
39662 arg1 = reinterpret_cast< wxMenu * >(argp1);
39663 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39664 if (!SWIG_IsOK(res2)) {
39665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39666 }
39667 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39668 {
39669 PyThreadState* __tstate = wxPyBeginAllowThreads();
39670 result = (bool)(arg1)->Delete(arg2);
39671 wxPyEndAllowThreads(__tstate);
39672 if (PyErr_Occurred()) SWIG_fail;
39673 }
39674 {
39675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39676 }
39677 return resultobj;
39678 fail:
39679 return NULL;
39680 }
39681
39682
39683 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39684 PyObject *resultobj = 0;
39685 wxMenu *arg1 = (wxMenu *) 0 ;
39686 void *argp1 = 0 ;
39687 int res1 = 0 ;
39688 PyObject *swig_obj[1] ;
39689
39690 if (!args) SWIG_fail;
39691 swig_obj[0] = args;
39692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39693 if (!SWIG_IsOK(res1)) {
39694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39695 }
39696 arg1 = reinterpret_cast< wxMenu * >(argp1);
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 wxMenu_Destroy(arg1);
39700 wxPyEndAllowThreads(__tstate);
39701 if (PyErr_Occurred()) SWIG_fail;
39702 }
39703 resultobj = SWIG_Py_Void();
39704 return resultobj;
39705 fail:
39706 return NULL;
39707 }
39708
39709
39710 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39711 PyObject *resultobj = 0;
39712 wxMenu *arg1 = (wxMenu *) 0 ;
39713 int arg2 ;
39714 bool result;
39715 void *argp1 = 0 ;
39716 int res1 = 0 ;
39717 int val2 ;
39718 int ecode2 = 0 ;
39719 PyObject * obj0 = 0 ;
39720 PyObject * obj1 = 0 ;
39721 char * kwnames[] = {
39722 (char *) "self",(char *) "id", NULL
39723 };
39724
39725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39727 if (!SWIG_IsOK(res1)) {
39728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39729 }
39730 arg1 = reinterpret_cast< wxMenu * >(argp1);
39731 ecode2 = SWIG_AsVal_int(obj1, &val2);
39732 if (!SWIG_IsOK(ecode2)) {
39733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39734 }
39735 arg2 = static_cast< int >(val2);
39736 {
39737 PyThreadState* __tstate = wxPyBeginAllowThreads();
39738 result = (bool)(arg1)->Destroy(arg2);
39739 wxPyEndAllowThreads(__tstate);
39740 if (PyErr_Occurred()) SWIG_fail;
39741 }
39742 {
39743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39744 }
39745 return resultobj;
39746 fail:
39747 return NULL;
39748 }
39749
39750
39751 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39752 PyObject *resultobj = 0;
39753 wxMenu *arg1 = (wxMenu *) 0 ;
39754 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39755 bool result;
39756 void *argp1 = 0 ;
39757 int res1 = 0 ;
39758 void *argp2 = 0 ;
39759 int res2 = 0 ;
39760 PyObject * obj0 = 0 ;
39761 PyObject * obj1 = 0 ;
39762 char * kwnames[] = {
39763 (char *) "self",(char *) "item", NULL
39764 };
39765
39766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39768 if (!SWIG_IsOK(res1)) {
39769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39770 }
39771 arg1 = reinterpret_cast< wxMenu * >(argp1);
39772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39773 if (!SWIG_IsOK(res2)) {
39774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39775 }
39776 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 result = (bool)(arg1)->Destroy(arg2);
39780 wxPyEndAllowThreads(__tstate);
39781 if (PyErr_Occurred()) SWIG_fail;
39782 }
39783 {
39784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39785 }
39786 return resultobj;
39787 fail:
39788 return NULL;
39789 }
39790
39791
39792 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39793 PyObject *resultobj = 0;
39794 wxMenu *arg1 = (wxMenu *) 0 ;
39795 size_t result;
39796 void *argp1 = 0 ;
39797 int res1 = 0 ;
39798 PyObject *swig_obj[1] ;
39799
39800 if (!args) SWIG_fail;
39801 swig_obj[0] = args;
39802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39803 if (!SWIG_IsOK(res1)) {
39804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39805 }
39806 arg1 = reinterpret_cast< wxMenu * >(argp1);
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39810 wxPyEndAllowThreads(__tstate);
39811 if (PyErr_Occurred()) SWIG_fail;
39812 }
39813 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39814 return resultobj;
39815 fail:
39816 return NULL;
39817 }
39818
39819
39820 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39821 PyObject *resultobj = 0;
39822 wxMenu *arg1 = (wxMenu *) 0 ;
39823 PyObject *result = 0 ;
39824 void *argp1 = 0 ;
39825 int res1 = 0 ;
39826 PyObject *swig_obj[1] ;
39827
39828 if (!args) SWIG_fail;
39829 swig_obj[0] = args;
39830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39831 if (!SWIG_IsOK(res1)) {
39832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39833 }
39834 arg1 = reinterpret_cast< wxMenu * >(argp1);
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 resultobj = result;
39842 return resultobj;
39843 fail:
39844 return NULL;
39845 }
39846
39847
39848 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39849 PyObject *resultobj = 0;
39850 wxMenu *arg1 = (wxMenu *) 0 ;
39851 wxString *arg2 = 0 ;
39852 int result;
39853 void *argp1 = 0 ;
39854 int res1 = 0 ;
39855 bool temp2 = false ;
39856 PyObject * obj0 = 0 ;
39857 PyObject * obj1 = 0 ;
39858 char * kwnames[] = {
39859 (char *) "self",(char *) "item", NULL
39860 };
39861
39862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39864 if (!SWIG_IsOK(res1)) {
39865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39866 }
39867 arg1 = reinterpret_cast< wxMenu * >(argp1);
39868 {
39869 arg2 = wxString_in_helper(obj1);
39870 if (arg2 == NULL) SWIG_fail;
39871 temp2 = true;
39872 }
39873 {
39874 PyThreadState* __tstate = wxPyBeginAllowThreads();
39875 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39876 wxPyEndAllowThreads(__tstate);
39877 if (PyErr_Occurred()) SWIG_fail;
39878 }
39879 resultobj = SWIG_From_int(static_cast< int >(result));
39880 {
39881 if (temp2)
39882 delete arg2;
39883 }
39884 return resultobj;
39885 fail:
39886 {
39887 if (temp2)
39888 delete arg2;
39889 }
39890 return NULL;
39891 }
39892
39893
39894 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39895 PyObject *resultobj = 0;
39896 wxMenu *arg1 = (wxMenu *) 0 ;
39897 int arg2 ;
39898 wxMenuItem *result = 0 ;
39899 void *argp1 = 0 ;
39900 int res1 = 0 ;
39901 int val2 ;
39902 int ecode2 = 0 ;
39903 PyObject * obj0 = 0 ;
39904 PyObject * obj1 = 0 ;
39905 char * kwnames[] = {
39906 (char *) "self",(char *) "id", NULL
39907 };
39908
39909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39911 if (!SWIG_IsOK(res1)) {
39912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39913 }
39914 arg1 = reinterpret_cast< wxMenu * >(argp1);
39915 ecode2 = SWIG_AsVal_int(obj1, &val2);
39916 if (!SWIG_IsOK(ecode2)) {
39917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39918 }
39919 arg2 = static_cast< int >(val2);
39920 {
39921 PyThreadState* __tstate = wxPyBeginAllowThreads();
39922 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39923 wxPyEndAllowThreads(__tstate);
39924 if (PyErr_Occurred()) SWIG_fail;
39925 }
39926 {
39927 resultobj = wxPyMake_wxObject(result, (bool)0);
39928 }
39929 return resultobj;
39930 fail:
39931 return NULL;
39932 }
39933
39934
39935 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39936 PyObject *resultobj = 0;
39937 wxMenu *arg1 = (wxMenu *) 0 ;
39938 size_t arg2 ;
39939 wxMenuItem *result = 0 ;
39940 void *argp1 = 0 ;
39941 int res1 = 0 ;
39942 size_t val2 ;
39943 int ecode2 = 0 ;
39944 PyObject * obj0 = 0 ;
39945 PyObject * obj1 = 0 ;
39946 char * kwnames[] = {
39947 (char *) "self",(char *) "position", NULL
39948 };
39949
39950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39952 if (!SWIG_IsOK(res1)) {
39953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39954 }
39955 arg1 = reinterpret_cast< wxMenu * >(argp1);
39956 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39957 if (!SWIG_IsOK(ecode2)) {
39958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39959 }
39960 arg2 = static_cast< size_t >(val2);
39961 {
39962 PyThreadState* __tstate = wxPyBeginAllowThreads();
39963 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39964 wxPyEndAllowThreads(__tstate);
39965 if (PyErr_Occurred()) SWIG_fail;
39966 }
39967 {
39968 resultobj = wxPyMake_wxObject(result, (bool)0);
39969 }
39970 return resultobj;
39971 fail:
39972 return NULL;
39973 }
39974
39975
39976 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39977 PyObject *resultobj = 0;
39978 wxMenu *arg1 = (wxMenu *) 0 ;
39979 int arg2 ;
39980 bool arg3 ;
39981 void *argp1 = 0 ;
39982 int res1 = 0 ;
39983 int val2 ;
39984 int ecode2 = 0 ;
39985 bool val3 ;
39986 int ecode3 = 0 ;
39987 PyObject * obj0 = 0 ;
39988 PyObject * obj1 = 0 ;
39989 PyObject * obj2 = 0 ;
39990 char * kwnames[] = {
39991 (char *) "self",(char *) "id",(char *) "enable", NULL
39992 };
39993
39994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39996 if (!SWIG_IsOK(res1)) {
39997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39998 }
39999 arg1 = reinterpret_cast< wxMenu * >(argp1);
40000 ecode2 = SWIG_AsVal_int(obj1, &val2);
40001 if (!SWIG_IsOK(ecode2)) {
40002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40003 }
40004 arg2 = static_cast< int >(val2);
40005 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40006 if (!SWIG_IsOK(ecode3)) {
40007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40008 }
40009 arg3 = static_cast< bool >(val3);
40010 {
40011 PyThreadState* __tstate = wxPyBeginAllowThreads();
40012 (arg1)->Enable(arg2,arg3);
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 resultobj = SWIG_Py_Void();
40017 return resultobj;
40018 fail:
40019 return NULL;
40020 }
40021
40022
40023 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40024 PyObject *resultobj = 0;
40025 wxMenu *arg1 = (wxMenu *) 0 ;
40026 int arg2 ;
40027 bool result;
40028 void *argp1 = 0 ;
40029 int res1 = 0 ;
40030 int val2 ;
40031 int ecode2 = 0 ;
40032 PyObject * obj0 = 0 ;
40033 PyObject * obj1 = 0 ;
40034 char * kwnames[] = {
40035 (char *) "self",(char *) "id", NULL
40036 };
40037
40038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40040 if (!SWIG_IsOK(res1)) {
40041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40042 }
40043 arg1 = reinterpret_cast< wxMenu * >(argp1);
40044 ecode2 = SWIG_AsVal_int(obj1, &val2);
40045 if (!SWIG_IsOK(ecode2)) {
40046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40047 }
40048 arg2 = static_cast< int >(val2);
40049 {
40050 PyThreadState* __tstate = wxPyBeginAllowThreads();
40051 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40052 wxPyEndAllowThreads(__tstate);
40053 if (PyErr_Occurred()) SWIG_fail;
40054 }
40055 {
40056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40057 }
40058 return resultobj;
40059 fail:
40060 return NULL;
40061 }
40062
40063
40064 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40065 PyObject *resultobj = 0;
40066 wxMenu *arg1 = (wxMenu *) 0 ;
40067 int arg2 ;
40068 bool arg3 ;
40069 void *argp1 = 0 ;
40070 int res1 = 0 ;
40071 int val2 ;
40072 int ecode2 = 0 ;
40073 bool val3 ;
40074 int ecode3 = 0 ;
40075 PyObject * obj0 = 0 ;
40076 PyObject * obj1 = 0 ;
40077 PyObject * obj2 = 0 ;
40078 char * kwnames[] = {
40079 (char *) "self",(char *) "id",(char *) "check", NULL
40080 };
40081
40082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40084 if (!SWIG_IsOK(res1)) {
40085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40086 }
40087 arg1 = reinterpret_cast< wxMenu * >(argp1);
40088 ecode2 = SWIG_AsVal_int(obj1, &val2);
40089 if (!SWIG_IsOK(ecode2)) {
40090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40091 }
40092 arg2 = static_cast< int >(val2);
40093 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40094 if (!SWIG_IsOK(ecode3)) {
40095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40096 }
40097 arg3 = static_cast< bool >(val3);
40098 {
40099 PyThreadState* __tstate = wxPyBeginAllowThreads();
40100 (arg1)->Check(arg2,arg3);
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 resultobj = SWIG_Py_Void();
40105 return resultobj;
40106 fail:
40107 return NULL;
40108 }
40109
40110
40111 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40112 PyObject *resultobj = 0;
40113 wxMenu *arg1 = (wxMenu *) 0 ;
40114 int arg2 ;
40115 bool result;
40116 void *argp1 = 0 ;
40117 int res1 = 0 ;
40118 int val2 ;
40119 int ecode2 = 0 ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 char * kwnames[] = {
40123 (char *) "self",(char *) "id", NULL
40124 };
40125
40126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40130 }
40131 arg1 = reinterpret_cast< wxMenu * >(argp1);
40132 ecode2 = SWIG_AsVal_int(obj1, &val2);
40133 if (!SWIG_IsOK(ecode2)) {
40134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40135 }
40136 arg2 = static_cast< int >(val2);
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 {
40144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40145 }
40146 return resultobj;
40147 fail:
40148 return NULL;
40149 }
40150
40151
40152 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40153 PyObject *resultobj = 0;
40154 wxMenu *arg1 = (wxMenu *) 0 ;
40155 int arg2 ;
40156 wxString *arg3 = 0 ;
40157 void *argp1 = 0 ;
40158 int res1 = 0 ;
40159 int val2 ;
40160 int ecode2 = 0 ;
40161 bool temp3 = false ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 PyObject * obj2 = 0 ;
40165 char * kwnames[] = {
40166 (char *) "self",(char *) "id",(char *) "label", NULL
40167 };
40168
40169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40171 if (!SWIG_IsOK(res1)) {
40172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40173 }
40174 arg1 = reinterpret_cast< wxMenu * >(argp1);
40175 ecode2 = SWIG_AsVal_int(obj1, &val2);
40176 if (!SWIG_IsOK(ecode2)) {
40177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40178 }
40179 arg2 = static_cast< int >(val2);
40180 {
40181 arg3 = wxString_in_helper(obj2);
40182 if (arg3 == NULL) SWIG_fail;
40183 temp3 = true;
40184 }
40185 {
40186 PyThreadState* __tstate = wxPyBeginAllowThreads();
40187 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 resultobj = SWIG_Py_Void();
40192 {
40193 if (temp3)
40194 delete arg3;
40195 }
40196 return resultobj;
40197 fail:
40198 {
40199 if (temp3)
40200 delete arg3;
40201 }
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40207 PyObject *resultobj = 0;
40208 wxMenu *arg1 = (wxMenu *) 0 ;
40209 int arg2 ;
40210 wxString result;
40211 void *argp1 = 0 ;
40212 int res1 = 0 ;
40213 int val2 ;
40214 int ecode2 = 0 ;
40215 PyObject * obj0 = 0 ;
40216 PyObject * obj1 = 0 ;
40217 char * kwnames[] = {
40218 (char *) "self",(char *) "id", NULL
40219 };
40220
40221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40223 if (!SWIG_IsOK(res1)) {
40224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40225 }
40226 arg1 = reinterpret_cast< wxMenu * >(argp1);
40227 ecode2 = SWIG_AsVal_int(obj1, &val2);
40228 if (!SWIG_IsOK(ecode2)) {
40229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40230 }
40231 arg2 = static_cast< int >(val2);
40232 {
40233 PyThreadState* __tstate = wxPyBeginAllowThreads();
40234 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40235 wxPyEndAllowThreads(__tstate);
40236 if (PyErr_Occurred()) SWIG_fail;
40237 }
40238 {
40239 #if wxUSE_UNICODE
40240 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40241 #else
40242 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40243 #endif
40244 }
40245 return resultobj;
40246 fail:
40247 return NULL;
40248 }
40249
40250
40251 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40252 PyObject *resultobj = 0;
40253 wxMenu *arg1 = (wxMenu *) 0 ;
40254 int arg2 ;
40255 wxString *arg3 = 0 ;
40256 void *argp1 = 0 ;
40257 int res1 = 0 ;
40258 int val2 ;
40259 int ecode2 = 0 ;
40260 bool temp3 = false ;
40261 PyObject * obj0 = 0 ;
40262 PyObject * obj1 = 0 ;
40263 PyObject * obj2 = 0 ;
40264 char * kwnames[] = {
40265 (char *) "self",(char *) "id",(char *) "helpString", NULL
40266 };
40267
40268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40270 if (!SWIG_IsOK(res1)) {
40271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40272 }
40273 arg1 = reinterpret_cast< wxMenu * >(argp1);
40274 ecode2 = SWIG_AsVal_int(obj1, &val2);
40275 if (!SWIG_IsOK(ecode2)) {
40276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40277 }
40278 arg2 = static_cast< int >(val2);
40279 {
40280 arg3 = wxString_in_helper(obj2);
40281 if (arg3 == NULL) SWIG_fail;
40282 temp3 = true;
40283 }
40284 {
40285 PyThreadState* __tstate = wxPyBeginAllowThreads();
40286 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40287 wxPyEndAllowThreads(__tstate);
40288 if (PyErr_Occurred()) SWIG_fail;
40289 }
40290 resultobj = SWIG_Py_Void();
40291 {
40292 if (temp3)
40293 delete arg3;
40294 }
40295 return resultobj;
40296 fail:
40297 {
40298 if (temp3)
40299 delete arg3;
40300 }
40301 return NULL;
40302 }
40303
40304
40305 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40306 PyObject *resultobj = 0;
40307 wxMenu *arg1 = (wxMenu *) 0 ;
40308 int arg2 ;
40309 wxString result;
40310 void *argp1 = 0 ;
40311 int res1 = 0 ;
40312 int val2 ;
40313 int ecode2 = 0 ;
40314 PyObject * obj0 = 0 ;
40315 PyObject * obj1 = 0 ;
40316 char * kwnames[] = {
40317 (char *) "self",(char *) "id", NULL
40318 };
40319
40320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40322 if (!SWIG_IsOK(res1)) {
40323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40324 }
40325 arg1 = reinterpret_cast< wxMenu * >(argp1);
40326 ecode2 = SWIG_AsVal_int(obj1, &val2);
40327 if (!SWIG_IsOK(ecode2)) {
40328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40329 }
40330 arg2 = static_cast< int >(val2);
40331 {
40332 PyThreadState* __tstate = wxPyBeginAllowThreads();
40333 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40334 wxPyEndAllowThreads(__tstate);
40335 if (PyErr_Occurred()) SWIG_fail;
40336 }
40337 {
40338 #if wxUSE_UNICODE
40339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40340 #else
40341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40342 #endif
40343 }
40344 return resultobj;
40345 fail:
40346 return NULL;
40347 }
40348
40349
40350 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40351 PyObject *resultobj = 0;
40352 wxMenu *arg1 = (wxMenu *) 0 ;
40353 wxString *arg2 = 0 ;
40354 void *argp1 = 0 ;
40355 int res1 = 0 ;
40356 bool temp2 = false ;
40357 PyObject * obj0 = 0 ;
40358 PyObject * obj1 = 0 ;
40359 char * kwnames[] = {
40360 (char *) "self",(char *) "title", NULL
40361 };
40362
40363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40365 if (!SWIG_IsOK(res1)) {
40366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40367 }
40368 arg1 = reinterpret_cast< wxMenu * >(argp1);
40369 {
40370 arg2 = wxString_in_helper(obj1);
40371 if (arg2 == NULL) SWIG_fail;
40372 temp2 = true;
40373 }
40374 {
40375 PyThreadState* __tstate = wxPyBeginAllowThreads();
40376 (arg1)->SetTitle((wxString const &)*arg2);
40377 wxPyEndAllowThreads(__tstate);
40378 if (PyErr_Occurred()) SWIG_fail;
40379 }
40380 resultobj = SWIG_Py_Void();
40381 {
40382 if (temp2)
40383 delete arg2;
40384 }
40385 return resultobj;
40386 fail:
40387 {
40388 if (temp2)
40389 delete arg2;
40390 }
40391 return NULL;
40392 }
40393
40394
40395 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40396 PyObject *resultobj = 0;
40397 wxMenu *arg1 = (wxMenu *) 0 ;
40398 wxString result;
40399 void *argp1 = 0 ;
40400 int res1 = 0 ;
40401 PyObject *swig_obj[1] ;
40402
40403 if (!args) SWIG_fail;
40404 swig_obj[0] = args;
40405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40406 if (!SWIG_IsOK(res1)) {
40407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40408 }
40409 arg1 = reinterpret_cast< wxMenu * >(argp1);
40410 {
40411 PyThreadState* __tstate = wxPyBeginAllowThreads();
40412 result = ((wxMenu const *)arg1)->GetTitle();
40413 wxPyEndAllowThreads(__tstate);
40414 if (PyErr_Occurred()) SWIG_fail;
40415 }
40416 {
40417 #if wxUSE_UNICODE
40418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40419 #else
40420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40421 #endif
40422 }
40423 return resultobj;
40424 fail:
40425 return NULL;
40426 }
40427
40428
40429 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40430 PyObject *resultobj = 0;
40431 wxMenu *arg1 = (wxMenu *) 0 ;
40432 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40433 void *argp1 = 0 ;
40434 int res1 = 0 ;
40435 void *argp2 = 0 ;
40436 int res2 = 0 ;
40437 PyObject * obj0 = 0 ;
40438 PyObject * obj1 = 0 ;
40439 char * kwnames[] = {
40440 (char *) "self",(char *) "handler", NULL
40441 };
40442
40443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40445 if (!SWIG_IsOK(res1)) {
40446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40447 }
40448 arg1 = reinterpret_cast< wxMenu * >(argp1);
40449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40450 if (!SWIG_IsOK(res2)) {
40451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40452 }
40453 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40454 {
40455 PyThreadState* __tstate = wxPyBeginAllowThreads();
40456 (arg1)->SetEventHandler(arg2);
40457 wxPyEndAllowThreads(__tstate);
40458 if (PyErr_Occurred()) SWIG_fail;
40459 }
40460 resultobj = SWIG_Py_Void();
40461 return resultobj;
40462 fail:
40463 return NULL;
40464 }
40465
40466
40467 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40468 PyObject *resultobj = 0;
40469 wxMenu *arg1 = (wxMenu *) 0 ;
40470 wxEvtHandler *result = 0 ;
40471 void *argp1 = 0 ;
40472 int res1 = 0 ;
40473 PyObject *swig_obj[1] ;
40474
40475 if (!args) SWIG_fail;
40476 swig_obj[0] = args;
40477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40478 if (!SWIG_IsOK(res1)) {
40479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40480 }
40481 arg1 = reinterpret_cast< wxMenu * >(argp1);
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 {
40489 resultobj = wxPyMake_wxObject(result, 0);
40490 }
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = 0;
40499 wxMenu *arg1 = (wxMenu *) 0 ;
40500 wxWindow *arg2 = (wxWindow *) 0 ;
40501 void *argp1 = 0 ;
40502 int res1 = 0 ;
40503 void *argp2 = 0 ;
40504 int res2 = 0 ;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char * kwnames[] = {
40508 (char *) "self",(char *) "win", NULL
40509 };
40510
40511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40515 }
40516 arg1 = reinterpret_cast< wxMenu * >(argp1);
40517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40518 if (!SWIG_IsOK(res2)) {
40519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40520 }
40521 arg2 = reinterpret_cast< wxWindow * >(argp2);
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 (arg1)->SetInvokingWindow(arg2);
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 resultobj = SWIG_Py_Void();
40529 return resultobj;
40530 fail:
40531 return NULL;
40532 }
40533
40534
40535 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40536 PyObject *resultobj = 0;
40537 wxMenu *arg1 = (wxMenu *) 0 ;
40538 wxWindow *result = 0 ;
40539 void *argp1 = 0 ;
40540 int res1 = 0 ;
40541 PyObject *swig_obj[1] ;
40542
40543 if (!args) SWIG_fail;
40544 swig_obj[0] = args;
40545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40546 if (!SWIG_IsOK(res1)) {
40547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40548 }
40549 arg1 = reinterpret_cast< wxMenu * >(argp1);
40550 {
40551 PyThreadState* __tstate = wxPyBeginAllowThreads();
40552 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 {
40557 resultobj = wxPyMake_wxObject(result, 0);
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40566 PyObject *resultobj = 0;
40567 wxMenu *arg1 = (wxMenu *) 0 ;
40568 long result;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 PyObject *swig_obj[1] ;
40572
40573 if (!args) SWIG_fail;
40574 swig_obj[0] = args;
40575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40576 if (!SWIG_IsOK(res1)) {
40577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40578 }
40579 arg1 = reinterpret_cast< wxMenu * >(argp1);
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 result = (long)((wxMenu const *)arg1)->GetStyle();
40583 wxPyEndAllowThreads(__tstate);
40584 if (PyErr_Occurred()) SWIG_fail;
40585 }
40586 resultobj = SWIG_From_long(static_cast< long >(result));
40587 return resultobj;
40588 fail:
40589 return NULL;
40590 }
40591
40592
40593 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40594 PyObject *resultobj = 0;
40595 wxMenu *arg1 = (wxMenu *) 0 ;
40596 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40597 void *argp1 = 0 ;
40598 int res1 = 0 ;
40599 void *argp2 = 0 ;
40600 int res2 = 0 ;
40601 PyObject * obj0 = 0 ;
40602 PyObject * obj1 = 0 ;
40603 char * kwnames[] = {
40604 (char *) "self",(char *) "source", NULL
40605 };
40606
40607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40609 if (!SWIG_IsOK(res1)) {
40610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40611 }
40612 arg1 = reinterpret_cast< wxMenu * >(argp1);
40613 if (obj1) {
40614 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40615 if (!SWIG_IsOK(res2)) {
40616 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40617 }
40618 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40619 }
40620 {
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 (arg1)->UpdateUI(arg2);
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_Py_Void();
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40634 PyObject *resultobj = 0;
40635 wxMenu *arg1 = (wxMenu *) 0 ;
40636 wxMenuBar *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_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40646 }
40647 arg1 = reinterpret_cast< wxMenu * >(argp1);
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 {
40655 resultobj = wxPyMake_wxObject(result, (bool)0);
40656 }
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40664 PyObject *resultobj = 0;
40665 wxMenu *arg1 = (wxMenu *) 0 ;
40666 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 void *argp2 = 0 ;
40670 int res2 = 0 ;
40671 PyObject * obj0 = 0 ;
40672 PyObject * obj1 = 0 ;
40673 char * kwnames[] = {
40674 (char *) "self",(char *) "menubar", NULL
40675 };
40676
40677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40679 if (!SWIG_IsOK(res1)) {
40680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40681 }
40682 arg1 = reinterpret_cast< wxMenu * >(argp1);
40683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40684 if (!SWIG_IsOK(res2)) {
40685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40686 }
40687 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->Attach(arg2);
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 resultobj = SWIG_Py_Void();
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40702 PyObject *resultobj = 0;
40703 wxMenu *arg1 = (wxMenu *) 0 ;
40704 void *argp1 = 0 ;
40705 int res1 = 0 ;
40706 PyObject *swig_obj[1] ;
40707
40708 if (!args) SWIG_fail;
40709 swig_obj[0] = args;
40710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40711 if (!SWIG_IsOK(res1)) {
40712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40713 }
40714 arg1 = reinterpret_cast< wxMenu * >(argp1);
40715 {
40716 PyThreadState* __tstate = wxPyBeginAllowThreads();
40717 (arg1)->Detach();
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 resultobj = SWIG_Py_Void();
40722 return resultobj;
40723 fail:
40724 return NULL;
40725 }
40726
40727
40728 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40729 PyObject *resultobj = 0;
40730 wxMenu *arg1 = (wxMenu *) 0 ;
40731 bool result;
40732 void *argp1 = 0 ;
40733 int res1 = 0 ;
40734 PyObject *swig_obj[1] ;
40735
40736 if (!args) SWIG_fail;
40737 swig_obj[0] = args;
40738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40739 if (!SWIG_IsOK(res1)) {
40740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40741 }
40742 arg1 = reinterpret_cast< wxMenu * >(argp1);
40743 {
40744 PyThreadState* __tstate = wxPyBeginAllowThreads();
40745 result = (bool)((wxMenu const *)arg1)->IsAttached();
40746 wxPyEndAllowThreads(__tstate);
40747 if (PyErr_Occurred()) SWIG_fail;
40748 }
40749 {
40750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40751 }
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj = 0;
40760 wxMenu *arg1 = (wxMenu *) 0 ;
40761 wxMenu *arg2 = (wxMenu *) 0 ;
40762 void *argp1 = 0 ;
40763 int res1 = 0 ;
40764 void *argp2 = 0 ;
40765 int res2 = 0 ;
40766 PyObject * obj0 = 0 ;
40767 PyObject * obj1 = 0 ;
40768 char * kwnames[] = {
40769 (char *) "self",(char *) "parent", NULL
40770 };
40771
40772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40774 if (!SWIG_IsOK(res1)) {
40775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40776 }
40777 arg1 = reinterpret_cast< wxMenu * >(argp1);
40778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40779 if (!SWIG_IsOK(res2)) {
40780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40781 }
40782 arg2 = reinterpret_cast< wxMenu * >(argp2);
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 (arg1)->SetParent(arg2);
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 resultobj = SWIG_Py_Void();
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40797 PyObject *resultobj = 0;
40798 wxMenu *arg1 = (wxMenu *) 0 ;
40799 wxMenu *result = 0 ;
40800 void *argp1 = 0 ;
40801 int res1 = 0 ;
40802 PyObject *swig_obj[1] ;
40803
40804 if (!args) SWIG_fail;
40805 swig_obj[0] = args;
40806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40807 if (!SWIG_IsOK(res1)) {
40808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40809 }
40810 arg1 = reinterpret_cast< wxMenu * >(argp1);
40811 {
40812 PyThreadState* __tstate = wxPyBeginAllowThreads();
40813 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40814 wxPyEndAllowThreads(__tstate);
40815 if (PyErr_Occurred()) SWIG_fail;
40816 }
40817 {
40818 resultobj = wxPyMake_wxObject(result, 0);
40819 }
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40827 PyObject *obj;
40828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40829 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40830 return SWIG_Py_Void();
40831 }
40832
40833 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40834 return SWIG_Python_InitShadowInstance(args);
40835 }
40836
40837 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40838 PyObject *resultobj = 0;
40839 long arg1 = (long) 0 ;
40840 wxMenuBar *result = 0 ;
40841 long val1 ;
40842 int ecode1 = 0 ;
40843 PyObject * obj0 = 0 ;
40844 char * kwnames[] = {
40845 (char *) "style", NULL
40846 };
40847
40848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40849 if (obj0) {
40850 ecode1 = SWIG_AsVal_long(obj0, &val1);
40851 if (!SWIG_IsOK(ecode1)) {
40852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40853 }
40854 arg1 = static_cast< long >(val1);
40855 }
40856 {
40857 if (!wxPyCheckForApp()) SWIG_fail;
40858 PyThreadState* __tstate = wxPyBeginAllowThreads();
40859 result = (wxMenuBar *)new wxMenuBar(arg1);
40860 wxPyEndAllowThreads(__tstate);
40861 if (PyErr_Occurred()) SWIG_fail;
40862 }
40863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40864 return resultobj;
40865 fail:
40866 return NULL;
40867 }
40868
40869
40870 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40871 PyObject *resultobj = 0;
40872 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40873 wxMenu *arg2 = (wxMenu *) 0 ;
40874 wxString *arg3 = 0 ;
40875 bool result;
40876 void *argp1 = 0 ;
40877 int res1 = 0 ;
40878 void *argp2 = 0 ;
40879 int res2 = 0 ;
40880 bool temp3 = false ;
40881 PyObject * obj0 = 0 ;
40882 PyObject * obj1 = 0 ;
40883 PyObject * obj2 = 0 ;
40884 char * kwnames[] = {
40885 (char *) "self",(char *) "menu",(char *) "title", NULL
40886 };
40887
40888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40890 if (!SWIG_IsOK(res1)) {
40891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40892 }
40893 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40895 if (!SWIG_IsOK(res2)) {
40896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40897 }
40898 arg2 = reinterpret_cast< wxMenu * >(argp2);
40899 {
40900 arg3 = wxString_in_helper(obj2);
40901 if (arg3 == NULL) SWIG_fail;
40902 temp3 = true;
40903 }
40904 {
40905 PyThreadState* __tstate = wxPyBeginAllowThreads();
40906 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40907 wxPyEndAllowThreads(__tstate);
40908 if (PyErr_Occurred()) SWIG_fail;
40909 }
40910 {
40911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40912 }
40913 {
40914 if (temp3)
40915 delete arg3;
40916 }
40917 return resultobj;
40918 fail:
40919 {
40920 if (temp3)
40921 delete arg3;
40922 }
40923 return NULL;
40924 }
40925
40926
40927 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40928 PyObject *resultobj = 0;
40929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40930 size_t arg2 ;
40931 wxMenu *arg3 = (wxMenu *) 0 ;
40932 wxString *arg4 = 0 ;
40933 bool result;
40934 void *argp1 = 0 ;
40935 int res1 = 0 ;
40936 size_t val2 ;
40937 int ecode2 = 0 ;
40938 void *argp3 = 0 ;
40939 int res3 = 0 ;
40940 bool temp4 = false ;
40941 PyObject * obj0 = 0 ;
40942 PyObject * obj1 = 0 ;
40943 PyObject * obj2 = 0 ;
40944 PyObject * obj3 = 0 ;
40945 char * kwnames[] = {
40946 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40947 };
40948
40949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40951 if (!SWIG_IsOK(res1)) {
40952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40953 }
40954 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40955 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40956 if (!SWIG_IsOK(ecode2)) {
40957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40958 }
40959 arg2 = static_cast< size_t >(val2);
40960 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40961 if (!SWIG_IsOK(res3)) {
40962 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40963 }
40964 arg3 = reinterpret_cast< wxMenu * >(argp3);
40965 {
40966 arg4 = wxString_in_helper(obj3);
40967 if (arg4 == NULL) SWIG_fail;
40968 temp4 = true;
40969 }
40970 {
40971 PyThreadState* __tstate = wxPyBeginAllowThreads();
40972 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40973 wxPyEndAllowThreads(__tstate);
40974 if (PyErr_Occurred()) SWIG_fail;
40975 }
40976 {
40977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40978 }
40979 {
40980 if (temp4)
40981 delete arg4;
40982 }
40983 return resultobj;
40984 fail:
40985 {
40986 if (temp4)
40987 delete arg4;
40988 }
40989 return NULL;
40990 }
40991
40992
40993 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40994 PyObject *resultobj = 0;
40995 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40996 size_t result;
40997 void *argp1 = 0 ;
40998 int res1 = 0 ;
40999 PyObject *swig_obj[1] ;
41000
41001 if (!args) SWIG_fail;
41002 swig_obj[0] = args;
41003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41004 if (!SWIG_IsOK(res1)) {
41005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41006 }
41007 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41022 PyObject *resultobj = 0;
41023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41024 size_t arg2 ;
41025 wxMenu *result = 0 ;
41026 void *argp1 = 0 ;
41027 int res1 = 0 ;
41028 size_t val2 ;
41029 int ecode2 = 0 ;
41030 PyObject * obj0 = 0 ;
41031 PyObject * obj1 = 0 ;
41032 char * kwnames[] = {
41033 (char *) "self",(char *) "pos", NULL
41034 };
41035
41036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41038 if (!SWIG_IsOK(res1)) {
41039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41040 }
41041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41042 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41043 if (!SWIG_IsOK(ecode2)) {
41044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41045 }
41046 arg2 = static_cast< size_t >(val2);
41047 {
41048 PyThreadState* __tstate = wxPyBeginAllowThreads();
41049 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41050 wxPyEndAllowThreads(__tstate);
41051 if (PyErr_Occurred()) SWIG_fail;
41052 }
41053 {
41054 resultobj = wxPyMake_wxObject(result, 0);
41055 }
41056 return resultobj;
41057 fail:
41058 return NULL;
41059 }
41060
41061
41062 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41063 PyObject *resultobj = 0;
41064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41065 size_t arg2 ;
41066 wxMenu *arg3 = (wxMenu *) 0 ;
41067 wxString *arg4 = 0 ;
41068 wxMenu *result = 0 ;
41069 void *argp1 = 0 ;
41070 int res1 = 0 ;
41071 size_t val2 ;
41072 int ecode2 = 0 ;
41073 void *argp3 = 0 ;
41074 int res3 = 0 ;
41075 bool temp4 = false ;
41076 PyObject * obj0 = 0 ;
41077 PyObject * obj1 = 0 ;
41078 PyObject * obj2 = 0 ;
41079 PyObject * obj3 = 0 ;
41080 char * kwnames[] = {
41081 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41082 };
41083
41084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41086 if (!SWIG_IsOK(res1)) {
41087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41088 }
41089 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41090 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41091 if (!SWIG_IsOK(ecode2)) {
41092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41093 }
41094 arg2 = static_cast< size_t >(val2);
41095 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41096 if (!SWIG_IsOK(res3)) {
41097 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41098 }
41099 arg3 = reinterpret_cast< wxMenu * >(argp3);
41100 {
41101 arg4 = wxString_in_helper(obj3);
41102 if (arg4 == NULL) SWIG_fail;
41103 temp4 = true;
41104 }
41105 {
41106 PyThreadState* __tstate = wxPyBeginAllowThreads();
41107 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41108 wxPyEndAllowThreads(__tstate);
41109 if (PyErr_Occurred()) SWIG_fail;
41110 }
41111 {
41112 resultobj = wxPyMake_wxObject(result, 0);
41113 }
41114 {
41115 if (temp4)
41116 delete arg4;
41117 }
41118 return resultobj;
41119 fail:
41120 {
41121 if (temp4)
41122 delete arg4;
41123 }
41124 return NULL;
41125 }
41126
41127
41128 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj = 0;
41130 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41131 size_t arg2 ;
41132 wxMenu *result = 0 ;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 size_t val2 ;
41136 int ecode2 = 0 ;
41137 PyObject * obj0 = 0 ;
41138 PyObject * obj1 = 0 ;
41139 char * kwnames[] = {
41140 (char *) "self",(char *) "pos", NULL
41141 };
41142
41143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41145 if (!SWIG_IsOK(res1)) {
41146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41147 }
41148 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41149 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41150 if (!SWIG_IsOK(ecode2)) {
41151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41152 }
41153 arg2 = static_cast< size_t >(val2);
41154 {
41155 PyThreadState* __tstate = wxPyBeginAllowThreads();
41156 result = (wxMenu *)(arg1)->Remove(arg2);
41157 wxPyEndAllowThreads(__tstate);
41158 if (PyErr_Occurred()) SWIG_fail;
41159 }
41160 {
41161 resultobj = wxPyMake_wxObject(result, 0);
41162 }
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj = 0;
41171 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41172 size_t arg2 ;
41173 bool arg3 ;
41174 void *argp1 = 0 ;
41175 int res1 = 0 ;
41176 size_t val2 ;
41177 int ecode2 = 0 ;
41178 bool val3 ;
41179 int ecode3 = 0 ;
41180 PyObject * obj0 = 0 ;
41181 PyObject * obj1 = 0 ;
41182 PyObject * obj2 = 0 ;
41183 char * kwnames[] = {
41184 (char *) "self",(char *) "pos",(char *) "enable", NULL
41185 };
41186
41187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41189 if (!SWIG_IsOK(res1)) {
41190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41191 }
41192 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41193 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41194 if (!SWIG_IsOK(ecode2)) {
41195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41196 }
41197 arg2 = static_cast< size_t >(val2);
41198 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41199 if (!SWIG_IsOK(ecode3)) {
41200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41201 }
41202 arg3 = static_cast< bool >(val3);
41203 {
41204 PyThreadState* __tstate = wxPyBeginAllowThreads();
41205 (arg1)->EnableTop(arg2,arg3);
41206 wxPyEndAllowThreads(__tstate);
41207 if (PyErr_Occurred()) SWIG_fail;
41208 }
41209 resultobj = SWIG_Py_Void();
41210 return resultobj;
41211 fail:
41212 return NULL;
41213 }
41214
41215
41216 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41217 PyObject *resultobj = 0;
41218 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41219 size_t arg2 ;
41220 bool result;
41221 void *argp1 = 0 ;
41222 int res1 = 0 ;
41223 size_t val2 ;
41224 int ecode2 = 0 ;
41225 PyObject * obj0 = 0 ;
41226 PyObject * obj1 = 0 ;
41227 char * kwnames[] = {
41228 (char *) "self",(char *) "pos", NULL
41229 };
41230
41231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41233 if (!SWIG_IsOK(res1)) {
41234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41235 }
41236 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41237 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41238 if (!SWIG_IsOK(ecode2)) {
41239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41240 }
41241 arg2 = static_cast< size_t >(val2);
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41245 wxPyEndAllowThreads(__tstate);
41246 if (PyErr_Occurred()) SWIG_fail;
41247 }
41248 {
41249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41250 }
41251 return resultobj;
41252 fail:
41253 return NULL;
41254 }
41255
41256
41257 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41258 PyObject *resultobj = 0;
41259 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41260 size_t arg2 ;
41261 wxString *arg3 = 0 ;
41262 void *argp1 = 0 ;
41263 int res1 = 0 ;
41264 size_t val2 ;
41265 int ecode2 = 0 ;
41266 bool temp3 = false ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 PyObject * obj2 = 0 ;
41270 char * kwnames[] = {
41271 (char *) "self",(char *) "pos",(char *) "label", NULL
41272 };
41273
41274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41276 if (!SWIG_IsOK(res1)) {
41277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41278 }
41279 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41280 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41281 if (!SWIG_IsOK(ecode2)) {
41282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41283 }
41284 arg2 = static_cast< size_t >(val2);
41285 {
41286 arg3 = wxString_in_helper(obj2);
41287 if (arg3 == NULL) SWIG_fail;
41288 temp3 = true;
41289 }
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 resultobj = SWIG_Py_Void();
41297 {
41298 if (temp3)
41299 delete arg3;
41300 }
41301 return resultobj;
41302 fail:
41303 {
41304 if (temp3)
41305 delete arg3;
41306 }
41307 return NULL;
41308 }
41309
41310
41311 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj = 0;
41313 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41314 size_t arg2 ;
41315 wxString result;
41316 void *argp1 = 0 ;
41317 int res1 = 0 ;
41318 size_t val2 ;
41319 int ecode2 = 0 ;
41320 PyObject * obj0 = 0 ;
41321 PyObject * obj1 = 0 ;
41322 char * kwnames[] = {
41323 (char *) "self",(char *) "pos", NULL
41324 };
41325
41326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41328 if (!SWIG_IsOK(res1)) {
41329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41330 }
41331 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41332 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41333 if (!SWIG_IsOK(ecode2)) {
41334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41335 }
41336 arg2 = static_cast< size_t >(val2);
41337 {
41338 PyThreadState* __tstate = wxPyBeginAllowThreads();
41339 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 {
41344 #if wxUSE_UNICODE
41345 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41346 #else
41347 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41348 #endif
41349 }
41350 return resultobj;
41351 fail:
41352 return NULL;
41353 }
41354
41355
41356 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41357 PyObject *resultobj = 0;
41358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41359 wxString *arg2 = 0 ;
41360 wxString *arg3 = 0 ;
41361 int result;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 bool temp2 = false ;
41365 bool temp3 = false ;
41366 PyObject * obj0 = 0 ;
41367 PyObject * obj1 = 0 ;
41368 PyObject * obj2 = 0 ;
41369 char * kwnames[] = {
41370 (char *) "self",(char *) "menu",(char *) "item", NULL
41371 };
41372
41373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41375 if (!SWIG_IsOK(res1)) {
41376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41377 }
41378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41379 {
41380 arg2 = wxString_in_helper(obj1);
41381 if (arg2 == NULL) SWIG_fail;
41382 temp2 = true;
41383 }
41384 {
41385 arg3 = wxString_in_helper(obj2);
41386 if (arg3 == NULL) SWIG_fail;
41387 temp3 = true;
41388 }
41389 {
41390 PyThreadState* __tstate = wxPyBeginAllowThreads();
41391 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 resultobj = SWIG_From_int(static_cast< int >(result));
41396 {
41397 if (temp2)
41398 delete arg2;
41399 }
41400 {
41401 if (temp3)
41402 delete arg3;
41403 }
41404 return resultobj;
41405 fail:
41406 {
41407 if (temp2)
41408 delete arg2;
41409 }
41410 {
41411 if (temp3)
41412 delete arg3;
41413 }
41414 return NULL;
41415 }
41416
41417
41418 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = 0;
41420 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41421 int arg2 ;
41422 wxMenuItem *result = 0 ;
41423 void *argp1 = 0 ;
41424 int res1 = 0 ;
41425 int val2 ;
41426 int ecode2 = 0 ;
41427 PyObject * obj0 = 0 ;
41428 PyObject * obj1 = 0 ;
41429 char * kwnames[] = {
41430 (char *) "self",(char *) "id", NULL
41431 };
41432
41433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41435 if (!SWIG_IsOK(res1)) {
41436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41437 }
41438 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41439 ecode2 = SWIG_AsVal_int(obj1, &val2);
41440 if (!SWIG_IsOK(ecode2)) {
41441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41442 }
41443 arg2 = static_cast< int >(val2);
41444 {
41445 PyThreadState* __tstate = wxPyBeginAllowThreads();
41446 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = wxPyMake_wxObject(result, (bool)0);
41452 }
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41460 PyObject *resultobj = 0;
41461 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41462 wxString *arg2 = 0 ;
41463 int result;
41464 void *argp1 = 0 ;
41465 int res1 = 0 ;
41466 bool temp2 = false ;
41467 PyObject * obj0 = 0 ;
41468 PyObject * obj1 = 0 ;
41469 char * kwnames[] = {
41470 (char *) "self",(char *) "title", NULL
41471 };
41472
41473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41475 if (!SWIG_IsOK(res1)) {
41476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41477 }
41478 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41479 {
41480 arg2 = wxString_in_helper(obj1);
41481 if (arg2 == NULL) SWIG_fail;
41482 temp2 = true;
41483 }
41484 {
41485 PyThreadState* __tstate = wxPyBeginAllowThreads();
41486 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 resultobj = SWIG_From_int(static_cast< int >(result));
41491 {
41492 if (temp2)
41493 delete arg2;
41494 }
41495 return resultobj;
41496 fail:
41497 {
41498 if (temp2)
41499 delete arg2;
41500 }
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj = 0;
41507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41508 int arg2 ;
41509 bool arg3 ;
41510 void *argp1 = 0 ;
41511 int res1 = 0 ;
41512 int val2 ;
41513 int ecode2 = 0 ;
41514 bool val3 ;
41515 int ecode3 = 0 ;
41516 PyObject * obj0 = 0 ;
41517 PyObject * obj1 = 0 ;
41518 PyObject * obj2 = 0 ;
41519 char * kwnames[] = {
41520 (char *) "self",(char *) "id",(char *) "enable", NULL
41521 };
41522
41523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41525 if (!SWIG_IsOK(res1)) {
41526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41527 }
41528 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41529 ecode2 = SWIG_AsVal_int(obj1, &val2);
41530 if (!SWIG_IsOK(ecode2)) {
41531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41532 }
41533 arg2 = static_cast< int >(val2);
41534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41535 if (!SWIG_IsOK(ecode3)) {
41536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41537 }
41538 arg3 = static_cast< bool >(val3);
41539 {
41540 PyThreadState* __tstate = wxPyBeginAllowThreads();
41541 (arg1)->Enable(arg2,arg3);
41542 wxPyEndAllowThreads(__tstate);
41543 if (PyErr_Occurred()) SWIG_fail;
41544 }
41545 resultobj = SWIG_Py_Void();
41546 return resultobj;
41547 fail:
41548 return NULL;
41549 }
41550
41551
41552 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41553 PyObject *resultobj = 0;
41554 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41555 int arg2 ;
41556 bool arg3 ;
41557 void *argp1 = 0 ;
41558 int res1 = 0 ;
41559 int val2 ;
41560 int ecode2 = 0 ;
41561 bool val3 ;
41562 int ecode3 = 0 ;
41563 PyObject * obj0 = 0 ;
41564 PyObject * obj1 = 0 ;
41565 PyObject * obj2 = 0 ;
41566 char * kwnames[] = {
41567 (char *) "self",(char *) "id",(char *) "check", NULL
41568 };
41569
41570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41572 if (!SWIG_IsOK(res1)) {
41573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41574 }
41575 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41576 ecode2 = SWIG_AsVal_int(obj1, &val2);
41577 if (!SWIG_IsOK(ecode2)) {
41578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41579 }
41580 arg2 = static_cast< int >(val2);
41581 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41582 if (!SWIG_IsOK(ecode3)) {
41583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41584 }
41585 arg3 = static_cast< bool >(val3);
41586 {
41587 PyThreadState* __tstate = wxPyBeginAllowThreads();
41588 (arg1)->Check(arg2,arg3);
41589 wxPyEndAllowThreads(__tstate);
41590 if (PyErr_Occurred()) SWIG_fail;
41591 }
41592 resultobj = SWIG_Py_Void();
41593 return resultobj;
41594 fail:
41595 return NULL;
41596 }
41597
41598
41599 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41600 PyObject *resultobj = 0;
41601 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41602 int arg2 ;
41603 bool result;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 int val2 ;
41607 int ecode2 = 0 ;
41608 PyObject * obj0 = 0 ;
41609 PyObject * obj1 = 0 ;
41610 char * kwnames[] = {
41611 (char *) "self",(char *) "id", NULL
41612 };
41613
41614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41616 if (!SWIG_IsOK(res1)) {
41617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41618 }
41619 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41620 ecode2 = SWIG_AsVal_int(obj1, &val2);
41621 if (!SWIG_IsOK(ecode2)) {
41622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41623 }
41624 arg2 = static_cast< int >(val2);
41625 {
41626 PyThreadState* __tstate = wxPyBeginAllowThreads();
41627 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41628 wxPyEndAllowThreads(__tstate);
41629 if (PyErr_Occurred()) SWIG_fail;
41630 }
41631 {
41632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41633 }
41634 return resultobj;
41635 fail:
41636 return NULL;
41637 }
41638
41639
41640 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41641 PyObject *resultobj = 0;
41642 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41643 int arg2 ;
41644 bool result;
41645 void *argp1 = 0 ;
41646 int res1 = 0 ;
41647 int val2 ;
41648 int ecode2 = 0 ;
41649 PyObject * obj0 = 0 ;
41650 PyObject * obj1 = 0 ;
41651 char * kwnames[] = {
41652 (char *) "self",(char *) "id", NULL
41653 };
41654
41655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41657 if (!SWIG_IsOK(res1)) {
41658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41659 }
41660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41661 ecode2 = SWIG_AsVal_int(obj1, &val2);
41662 if (!SWIG_IsOK(ecode2)) {
41663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41664 }
41665 arg2 = static_cast< int >(val2);
41666 {
41667 PyThreadState* __tstate = wxPyBeginAllowThreads();
41668 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41669 wxPyEndAllowThreads(__tstate);
41670 if (PyErr_Occurred()) SWIG_fail;
41671 }
41672 {
41673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41674 }
41675 return resultobj;
41676 fail:
41677 return NULL;
41678 }
41679
41680
41681 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41682 PyObject *resultobj = 0;
41683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41684 int arg2 ;
41685 wxString *arg3 = 0 ;
41686 void *argp1 = 0 ;
41687 int res1 = 0 ;
41688 int val2 ;
41689 int ecode2 = 0 ;
41690 bool temp3 = false ;
41691 PyObject * obj0 = 0 ;
41692 PyObject * obj1 = 0 ;
41693 PyObject * obj2 = 0 ;
41694 char * kwnames[] = {
41695 (char *) "self",(char *) "id",(char *) "label", NULL
41696 };
41697
41698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41700 if (!SWIG_IsOK(res1)) {
41701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41702 }
41703 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41704 ecode2 = SWIG_AsVal_int(obj1, &val2);
41705 if (!SWIG_IsOK(ecode2)) {
41706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41707 }
41708 arg2 = static_cast< int >(val2);
41709 {
41710 arg3 = wxString_in_helper(obj2);
41711 if (arg3 == NULL) SWIG_fail;
41712 temp3 = true;
41713 }
41714 {
41715 PyThreadState* __tstate = wxPyBeginAllowThreads();
41716 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41717 wxPyEndAllowThreads(__tstate);
41718 if (PyErr_Occurred()) SWIG_fail;
41719 }
41720 resultobj = SWIG_Py_Void();
41721 {
41722 if (temp3)
41723 delete arg3;
41724 }
41725 return resultobj;
41726 fail:
41727 {
41728 if (temp3)
41729 delete arg3;
41730 }
41731 return NULL;
41732 }
41733
41734
41735 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41736 PyObject *resultobj = 0;
41737 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41738 int arg2 ;
41739 wxString result;
41740 void *argp1 = 0 ;
41741 int res1 = 0 ;
41742 int val2 ;
41743 int ecode2 = 0 ;
41744 PyObject * obj0 = 0 ;
41745 PyObject * obj1 = 0 ;
41746 char * kwnames[] = {
41747 (char *) "self",(char *) "id", NULL
41748 };
41749
41750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41752 if (!SWIG_IsOK(res1)) {
41753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41754 }
41755 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41756 ecode2 = SWIG_AsVal_int(obj1, &val2);
41757 if (!SWIG_IsOK(ecode2)) {
41758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41759 }
41760 arg2 = static_cast< int >(val2);
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 {
41768 #if wxUSE_UNICODE
41769 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41770 #else
41771 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41772 #endif
41773 }
41774 return resultobj;
41775 fail:
41776 return NULL;
41777 }
41778
41779
41780 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41781 PyObject *resultobj = 0;
41782 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41783 int arg2 ;
41784 wxString *arg3 = 0 ;
41785 void *argp1 = 0 ;
41786 int res1 = 0 ;
41787 int val2 ;
41788 int ecode2 = 0 ;
41789 bool temp3 = false ;
41790 PyObject * obj0 = 0 ;
41791 PyObject * obj1 = 0 ;
41792 PyObject * obj2 = 0 ;
41793 char * kwnames[] = {
41794 (char *) "self",(char *) "id",(char *) "helpString", NULL
41795 };
41796
41797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41799 if (!SWIG_IsOK(res1)) {
41800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41801 }
41802 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41803 ecode2 = SWIG_AsVal_int(obj1, &val2);
41804 if (!SWIG_IsOK(ecode2)) {
41805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41806 }
41807 arg2 = static_cast< int >(val2);
41808 {
41809 arg3 = wxString_in_helper(obj2);
41810 if (arg3 == NULL) SWIG_fail;
41811 temp3 = true;
41812 }
41813 {
41814 PyThreadState* __tstate = wxPyBeginAllowThreads();
41815 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41816 wxPyEndAllowThreads(__tstate);
41817 if (PyErr_Occurred()) SWIG_fail;
41818 }
41819 resultobj = SWIG_Py_Void();
41820 {
41821 if (temp3)
41822 delete arg3;
41823 }
41824 return resultobj;
41825 fail:
41826 {
41827 if (temp3)
41828 delete arg3;
41829 }
41830 return NULL;
41831 }
41832
41833
41834 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41835 PyObject *resultobj = 0;
41836 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41837 int arg2 ;
41838 wxString result;
41839 void *argp1 = 0 ;
41840 int res1 = 0 ;
41841 int val2 ;
41842 int ecode2 = 0 ;
41843 PyObject * obj0 = 0 ;
41844 PyObject * obj1 = 0 ;
41845 char * kwnames[] = {
41846 (char *) "self",(char *) "id", NULL
41847 };
41848
41849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",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_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41853 }
41854 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41855 ecode2 = SWIG_AsVal_int(obj1, &val2);
41856 if (!SWIG_IsOK(ecode2)) {
41857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41858 }
41859 arg2 = static_cast< int >(val2);
41860 {
41861 PyThreadState* __tstate = wxPyBeginAllowThreads();
41862 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 {
41867 #if wxUSE_UNICODE
41868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41869 #else
41870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41871 #endif
41872 }
41873 return resultobj;
41874 fail:
41875 return NULL;
41876 }
41877
41878
41879 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41880 PyObject *resultobj = 0;
41881 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41882 wxFrame *result = 0 ;
41883 void *argp1 = 0 ;
41884 int res1 = 0 ;
41885 PyObject *swig_obj[1] ;
41886
41887 if (!args) SWIG_fail;
41888 swig_obj[0] = args;
41889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41890 if (!SWIG_IsOK(res1)) {
41891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41892 }
41893 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41894 {
41895 PyThreadState* __tstate = wxPyBeginAllowThreads();
41896 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41897 wxPyEndAllowThreads(__tstate);
41898 if (PyErr_Occurred()) SWIG_fail;
41899 }
41900 {
41901 resultobj = wxPyMake_wxObject(result, (bool)0);
41902 }
41903 return resultobj;
41904 fail:
41905 return NULL;
41906 }
41907
41908
41909 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41910 PyObject *resultobj = 0;
41911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41912 bool result;
41913 void *argp1 = 0 ;
41914 int res1 = 0 ;
41915 PyObject *swig_obj[1] ;
41916
41917 if (!args) SWIG_fail;
41918 swig_obj[0] = args;
41919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41920 if (!SWIG_IsOK(res1)) {
41921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41922 }
41923 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41924 {
41925 PyThreadState* __tstate = wxPyBeginAllowThreads();
41926 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41927 wxPyEndAllowThreads(__tstate);
41928 if (PyErr_Occurred()) SWIG_fail;
41929 }
41930 {
41931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41932 }
41933 return resultobj;
41934 fail:
41935 return NULL;
41936 }
41937
41938
41939 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41940 PyObject *resultobj = 0;
41941 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41942 wxFrame *arg2 = (wxFrame *) 0 ;
41943 void *argp1 = 0 ;
41944 int res1 = 0 ;
41945 void *argp2 = 0 ;
41946 int res2 = 0 ;
41947 PyObject * obj0 = 0 ;
41948 PyObject * obj1 = 0 ;
41949 char * kwnames[] = {
41950 (char *) "self",(char *) "frame", NULL
41951 };
41952
41953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41955 if (!SWIG_IsOK(res1)) {
41956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41957 }
41958 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41959 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41960 if (!SWIG_IsOK(res2)) {
41961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41962 }
41963 arg2 = reinterpret_cast< wxFrame * >(argp2);
41964 {
41965 PyThreadState* __tstate = wxPyBeginAllowThreads();
41966 (arg1)->Attach(arg2);
41967 wxPyEndAllowThreads(__tstate);
41968 if (PyErr_Occurred()) SWIG_fail;
41969 }
41970 resultobj = SWIG_Py_Void();
41971 return resultobj;
41972 fail:
41973 return NULL;
41974 }
41975
41976
41977 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41978 PyObject *resultobj = 0;
41979 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41980 void *argp1 = 0 ;
41981 int res1 = 0 ;
41982 PyObject *swig_obj[1] ;
41983
41984 if (!args) SWIG_fail;
41985 swig_obj[0] = args;
41986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41987 if (!SWIG_IsOK(res1)) {
41988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41989 }
41990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41991 {
41992 PyThreadState* __tstate = wxPyBeginAllowThreads();
41993 (arg1)->Detach();
41994 wxPyEndAllowThreads(__tstate);
41995 if (PyErr_Occurred()) SWIG_fail;
41996 }
41997 resultobj = SWIG_Py_Void();
41998 return resultobj;
41999 fail:
42000 return NULL;
42001 }
42002
42003
42004 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj = 0;
42006 bool arg1 ;
42007 bool val1 ;
42008 int ecode1 = 0 ;
42009 PyObject * obj0 = 0 ;
42010 char * kwnames[] = {
42011 (char *) "enable", NULL
42012 };
42013
42014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42015 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42016 if (!SWIG_IsOK(ecode1)) {
42017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42018 }
42019 arg1 = static_cast< bool >(val1);
42020 {
42021 PyThreadState* __tstate = wxPyBeginAllowThreads();
42022 wxMenuBar_SetAutoWindowMenu(arg1);
42023 wxPyEndAllowThreads(__tstate);
42024 if (PyErr_Occurred()) SWIG_fail;
42025 }
42026 resultobj = SWIG_Py_Void();
42027 return resultobj;
42028 fail:
42029 return NULL;
42030 }
42031
42032
42033 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42034 PyObject *resultobj = 0;
42035 bool result;
42036
42037 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42038 {
42039 PyThreadState* __tstate = wxPyBeginAllowThreads();
42040 result = (bool)wxMenuBar_GetAutoWindowMenu();
42041 wxPyEndAllowThreads(__tstate);
42042 if (PyErr_Occurred()) SWIG_fail;
42043 }
42044 {
42045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42046 }
42047 return resultobj;
42048 fail:
42049 return NULL;
42050 }
42051
42052
42053 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42054 PyObject *obj;
42055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42056 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42057 return SWIG_Py_Void();
42058 }
42059
42060 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42061 return SWIG_Python_InitShadowInstance(args);
42062 }
42063
42064 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42065 PyObject *resultobj = 0;
42066 wxMenu *arg1 = (wxMenu *) NULL ;
42067 int arg2 = (int) wxID_ANY ;
42068 wxString const &arg3_defvalue = wxPyEmptyString ;
42069 wxString *arg3 = (wxString *) &arg3_defvalue ;
42070 wxString const &arg4_defvalue = wxPyEmptyString ;
42071 wxString *arg4 = (wxString *) &arg4_defvalue ;
42072 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42073 wxMenu *arg6 = (wxMenu *) NULL ;
42074 wxMenuItem *result = 0 ;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 int val2 ;
42078 int ecode2 = 0 ;
42079 bool temp3 = false ;
42080 bool temp4 = false ;
42081 int val5 ;
42082 int ecode5 = 0 ;
42083 void *argp6 = 0 ;
42084 int res6 = 0 ;
42085 PyObject * obj0 = 0 ;
42086 PyObject * obj1 = 0 ;
42087 PyObject * obj2 = 0 ;
42088 PyObject * obj3 = 0 ;
42089 PyObject * obj4 = 0 ;
42090 PyObject * obj5 = 0 ;
42091 char * kwnames[] = {
42092 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42093 };
42094
42095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42096 if (obj0) {
42097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42098 if (!SWIG_IsOK(res1)) {
42099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42100 }
42101 arg1 = reinterpret_cast< wxMenu * >(argp1);
42102 }
42103 if (obj1) {
42104 ecode2 = SWIG_AsVal_int(obj1, &val2);
42105 if (!SWIG_IsOK(ecode2)) {
42106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42107 }
42108 arg2 = static_cast< int >(val2);
42109 }
42110 if (obj2) {
42111 {
42112 arg3 = wxString_in_helper(obj2);
42113 if (arg3 == NULL) SWIG_fail;
42114 temp3 = true;
42115 }
42116 }
42117 if (obj3) {
42118 {
42119 arg4 = wxString_in_helper(obj3);
42120 if (arg4 == NULL) SWIG_fail;
42121 temp4 = true;
42122 }
42123 }
42124 if (obj4) {
42125 ecode5 = SWIG_AsVal_int(obj4, &val5);
42126 if (!SWIG_IsOK(ecode5)) {
42127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42128 }
42129 arg5 = static_cast< wxItemKind >(val5);
42130 }
42131 if (obj5) {
42132 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42133 if (!SWIG_IsOK(res6)) {
42134 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42135 }
42136 arg6 = reinterpret_cast< wxMenu * >(argp6);
42137 }
42138 {
42139 PyThreadState* __tstate = wxPyBeginAllowThreads();
42140 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 {
42145 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42146 }
42147 {
42148 if (temp3)
42149 delete arg3;
42150 }
42151 {
42152 if (temp4)
42153 delete arg4;
42154 }
42155 return resultobj;
42156 fail:
42157 {
42158 if (temp3)
42159 delete arg3;
42160 }
42161 {
42162 if (temp4)
42163 delete arg4;
42164 }
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42170 PyObject *resultobj = 0;
42171 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42172 void *argp1 = 0 ;
42173 int res1 = 0 ;
42174 PyObject *swig_obj[1] ;
42175
42176 if (!args) SWIG_fail;
42177 swig_obj[0] = args;
42178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42179 if (!SWIG_IsOK(res1)) {
42180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42181 }
42182 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 delete arg1;
42186
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 resultobj = SWIG_Py_Void();
42191 return resultobj;
42192 fail:
42193 return NULL;
42194 }
42195
42196
42197 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42198 PyObject *resultobj = 0;
42199 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42200 wxMenu *result = 0 ;
42201 void *argp1 = 0 ;
42202 int res1 = 0 ;
42203 PyObject *swig_obj[1] ;
42204
42205 if (!args) SWIG_fail;
42206 swig_obj[0] = args;
42207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42208 if (!SWIG_IsOK(res1)) {
42209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42210 }
42211 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42212 {
42213 PyThreadState* __tstate = wxPyBeginAllowThreads();
42214 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42215 wxPyEndAllowThreads(__tstate);
42216 if (PyErr_Occurred()) SWIG_fail;
42217 }
42218 {
42219 resultobj = wxPyMake_wxObject(result, 0);
42220 }
42221 return resultobj;
42222 fail:
42223 return NULL;
42224 }
42225
42226
42227 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42228 PyObject *resultobj = 0;
42229 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42230 wxMenu *arg2 = (wxMenu *) 0 ;
42231 void *argp1 = 0 ;
42232 int res1 = 0 ;
42233 void *argp2 = 0 ;
42234 int res2 = 0 ;
42235 PyObject * obj0 = 0 ;
42236 PyObject * obj1 = 0 ;
42237 char * kwnames[] = {
42238 (char *) "self",(char *) "menu", NULL
42239 };
42240
42241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42243 if (!SWIG_IsOK(res1)) {
42244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42245 }
42246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42248 if (!SWIG_IsOK(res2)) {
42249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42250 }
42251 arg2 = reinterpret_cast< wxMenu * >(argp2);
42252 {
42253 PyThreadState* __tstate = wxPyBeginAllowThreads();
42254 (arg1)->SetMenu(arg2);
42255 wxPyEndAllowThreads(__tstate);
42256 if (PyErr_Occurred()) SWIG_fail;
42257 }
42258 resultobj = SWIG_Py_Void();
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj = 0;
42267 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42268 int arg2 ;
42269 void *argp1 = 0 ;
42270 int res1 = 0 ;
42271 int val2 ;
42272 int ecode2 = 0 ;
42273 PyObject * obj0 = 0 ;
42274 PyObject * obj1 = 0 ;
42275 char * kwnames[] = {
42276 (char *) "self",(char *) "id", NULL
42277 };
42278
42279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42283 }
42284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42285 ecode2 = SWIG_AsVal_int(obj1, &val2);
42286 if (!SWIG_IsOK(ecode2)) {
42287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42288 }
42289 arg2 = static_cast< int >(val2);
42290 {
42291 PyThreadState* __tstate = wxPyBeginAllowThreads();
42292 (arg1)->SetId(arg2);
42293 wxPyEndAllowThreads(__tstate);
42294 if (PyErr_Occurred()) SWIG_fail;
42295 }
42296 resultobj = SWIG_Py_Void();
42297 return resultobj;
42298 fail:
42299 return NULL;
42300 }
42301
42302
42303 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42304 PyObject *resultobj = 0;
42305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42306 int result;
42307 void *argp1 = 0 ;
42308 int res1 = 0 ;
42309 PyObject *swig_obj[1] ;
42310
42311 if (!args) SWIG_fail;
42312 swig_obj[0] = args;
42313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42314 if (!SWIG_IsOK(res1)) {
42315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42316 }
42317 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42318 {
42319 PyThreadState* __tstate = wxPyBeginAllowThreads();
42320 result = (int)((wxMenuItem const *)arg1)->GetId();
42321 wxPyEndAllowThreads(__tstate);
42322 if (PyErr_Occurred()) SWIG_fail;
42323 }
42324 resultobj = SWIG_From_int(static_cast< int >(result));
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42332 PyObject *resultobj = 0;
42333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42334 bool result;
42335 void *argp1 = 0 ;
42336 int res1 = 0 ;
42337 PyObject *swig_obj[1] ;
42338
42339 if (!args) SWIG_fail;
42340 swig_obj[0] = args;
42341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42342 if (!SWIG_IsOK(res1)) {
42343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42344 }
42345 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42346 {
42347 PyThreadState* __tstate = wxPyBeginAllowThreads();
42348 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42349 wxPyEndAllowThreads(__tstate);
42350 if (PyErr_Occurred()) SWIG_fail;
42351 }
42352 {
42353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42354 }
42355 return resultobj;
42356 fail:
42357 return NULL;
42358 }
42359
42360
42361 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42362 PyObject *resultobj = 0;
42363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42364 wxString *arg2 = 0 ;
42365 void *argp1 = 0 ;
42366 int res1 = 0 ;
42367 bool temp2 = false ;
42368 PyObject * obj0 = 0 ;
42369 PyObject * obj1 = 0 ;
42370 char * kwnames[] = {
42371 (char *) "self",(char *) "str", NULL
42372 };
42373
42374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42376 if (!SWIG_IsOK(res1)) {
42377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42378 }
42379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42380 {
42381 arg2 = wxString_in_helper(obj1);
42382 if (arg2 == NULL) SWIG_fail;
42383 temp2 = true;
42384 }
42385 {
42386 PyThreadState* __tstate = wxPyBeginAllowThreads();
42387 (arg1)->SetText((wxString const &)*arg2);
42388 wxPyEndAllowThreads(__tstate);
42389 if (PyErr_Occurred()) SWIG_fail;
42390 }
42391 resultobj = SWIG_Py_Void();
42392 {
42393 if (temp2)
42394 delete arg2;
42395 }
42396 return resultobj;
42397 fail:
42398 {
42399 if (temp2)
42400 delete arg2;
42401 }
42402 return NULL;
42403 }
42404
42405
42406 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42407 PyObject *resultobj = 0;
42408 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42409 wxString result;
42410 void *argp1 = 0 ;
42411 int res1 = 0 ;
42412 PyObject *swig_obj[1] ;
42413
42414 if (!args) SWIG_fail;
42415 swig_obj[0] = args;
42416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42417 if (!SWIG_IsOK(res1)) {
42418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42419 }
42420 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42421 {
42422 PyThreadState* __tstate = wxPyBeginAllowThreads();
42423 result = ((wxMenuItem const *)arg1)->GetLabel();
42424 wxPyEndAllowThreads(__tstate);
42425 if (PyErr_Occurred()) SWIG_fail;
42426 }
42427 {
42428 #if wxUSE_UNICODE
42429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42430 #else
42431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42432 #endif
42433 }
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42441 PyObject *resultobj = 0;
42442 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42443 wxString *result = 0 ;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 PyObject *swig_obj[1] ;
42447
42448 if (!args) SWIG_fail;
42449 swig_obj[0] = args;
42450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 {
42458 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42459 result = (wxString *) &_result_ref;
42460 }
42461 wxPyEndAllowThreads(__tstate);
42462 if (PyErr_Occurred()) SWIG_fail;
42463 }
42464 {
42465 #if wxUSE_UNICODE
42466 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42467 #else
42468 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42469 #endif
42470 }
42471 return resultobj;
42472 fail:
42473 return NULL;
42474 }
42475
42476
42477 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42478 PyObject *resultobj = 0;
42479 wxString *arg1 = 0 ;
42480 wxString result;
42481 bool temp1 = false ;
42482 PyObject * obj0 = 0 ;
42483 char * kwnames[] = {
42484 (char *) "text", NULL
42485 };
42486
42487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42488 {
42489 arg1 = wxString_in_helper(obj0);
42490 if (arg1 == NULL) SWIG_fail;
42491 temp1 = true;
42492 }
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 {
42500 #if wxUSE_UNICODE
42501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42502 #else
42503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42504 #endif
42505 }
42506 {
42507 if (temp1)
42508 delete arg1;
42509 }
42510 return resultobj;
42511 fail:
42512 {
42513 if (temp1)
42514 delete arg1;
42515 }
42516 return NULL;
42517 }
42518
42519
42520 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42521 PyObject *resultobj = 0;
42522 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42523 wxItemKind result;
42524 void *argp1 = 0 ;
42525 int res1 = 0 ;
42526 PyObject *swig_obj[1] ;
42527
42528 if (!args) SWIG_fail;
42529 swig_obj[0] = args;
42530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42531 if (!SWIG_IsOK(res1)) {
42532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42533 }
42534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42535 {
42536 PyThreadState* __tstate = wxPyBeginAllowThreads();
42537 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 resultobj = SWIG_From_int(static_cast< int >(result));
42542 return resultobj;
42543 fail:
42544 return NULL;
42545 }
42546
42547
42548 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42549 PyObject *resultobj = 0;
42550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42551 wxItemKind arg2 ;
42552 void *argp1 = 0 ;
42553 int res1 = 0 ;
42554 int val2 ;
42555 int ecode2 = 0 ;
42556 PyObject * obj0 = 0 ;
42557 PyObject * obj1 = 0 ;
42558 char * kwnames[] = {
42559 (char *) "self",(char *) "kind", NULL
42560 };
42561
42562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42564 if (!SWIG_IsOK(res1)) {
42565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42566 }
42567 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42568 ecode2 = SWIG_AsVal_int(obj1, &val2);
42569 if (!SWIG_IsOK(ecode2)) {
42570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42571 }
42572 arg2 = static_cast< wxItemKind >(val2);
42573 {
42574 PyThreadState* __tstate = wxPyBeginAllowThreads();
42575 (arg1)->SetKind(arg2);
42576 wxPyEndAllowThreads(__tstate);
42577 if (PyErr_Occurred()) SWIG_fail;
42578 }
42579 resultobj = SWIG_Py_Void();
42580 return resultobj;
42581 fail:
42582 return NULL;
42583 }
42584
42585
42586 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42587 PyObject *resultobj = 0;
42588 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42589 bool arg2 ;
42590 void *argp1 = 0 ;
42591 int res1 = 0 ;
42592 bool val2 ;
42593 int ecode2 = 0 ;
42594 PyObject * obj0 = 0 ;
42595 PyObject * obj1 = 0 ;
42596 char * kwnames[] = {
42597 (char *) "self",(char *) "checkable", NULL
42598 };
42599
42600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42602 if (!SWIG_IsOK(res1)) {
42603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42604 }
42605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42606 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42607 if (!SWIG_IsOK(ecode2)) {
42608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42609 }
42610 arg2 = static_cast< bool >(val2);
42611 {
42612 PyThreadState* __tstate = wxPyBeginAllowThreads();
42613 (arg1)->SetCheckable(arg2);
42614 wxPyEndAllowThreads(__tstate);
42615 if (PyErr_Occurred()) SWIG_fail;
42616 }
42617 resultobj = SWIG_Py_Void();
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42625 PyObject *resultobj = 0;
42626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42627 bool result;
42628 void *argp1 = 0 ;
42629 int res1 = 0 ;
42630 PyObject *swig_obj[1] ;
42631
42632 if (!args) SWIG_fail;
42633 swig_obj[0] = args;
42634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42635 if (!SWIG_IsOK(res1)) {
42636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42637 }
42638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 {
42646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42647 }
42648 return resultobj;
42649 fail:
42650 return NULL;
42651 }
42652
42653
42654 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42655 PyObject *resultobj = 0;
42656 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42657 bool result;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 PyObject *swig_obj[1] ;
42661
42662 if (!args) SWIG_fail;
42663 swig_obj[0] = args;
42664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 {
42676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42677 }
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42685 PyObject *resultobj = 0;
42686 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42687 wxMenu *arg2 = (wxMenu *) 0 ;
42688 void *argp1 = 0 ;
42689 int res1 = 0 ;
42690 void *argp2 = 0 ;
42691 int res2 = 0 ;
42692 PyObject * obj0 = 0 ;
42693 PyObject * obj1 = 0 ;
42694 char * kwnames[] = {
42695 (char *) "self",(char *) "menu", NULL
42696 };
42697
42698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42700 if (!SWIG_IsOK(res1)) {
42701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42702 }
42703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42705 if (!SWIG_IsOK(res2)) {
42706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42707 }
42708 arg2 = reinterpret_cast< wxMenu * >(argp2);
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 (arg1)->SetSubMenu(arg2);
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 resultobj = SWIG_Py_Void();
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42723 PyObject *resultobj = 0;
42724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42725 wxMenu *result = 0 ;
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_wxMenuItem, 0 | 0 );
42733 if (!SWIG_IsOK(res1)) {
42734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42735 }
42736 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42737 {
42738 PyThreadState* __tstate = wxPyBeginAllowThreads();
42739 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 {
42744 resultobj = wxPyMake_wxObject(result, 0);
42745 }
42746 return resultobj;
42747 fail:
42748 return NULL;
42749 }
42750
42751
42752 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42753 PyObject *resultobj = 0;
42754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42755 bool arg2 = (bool) true ;
42756 void *argp1 = 0 ;
42757 int res1 = 0 ;
42758 bool val2 ;
42759 int ecode2 = 0 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 char * kwnames[] = {
42763 (char *) "self",(char *) "enable", NULL
42764 };
42765
42766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42772 if (obj1) {
42773 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42774 if (!SWIG_IsOK(ecode2)) {
42775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42776 }
42777 arg2 = static_cast< bool >(val2);
42778 }
42779 {
42780 PyThreadState* __tstate = wxPyBeginAllowThreads();
42781 (arg1)->Enable(arg2);
42782 wxPyEndAllowThreads(__tstate);
42783 if (PyErr_Occurred()) SWIG_fail;
42784 }
42785 resultobj = SWIG_Py_Void();
42786 return resultobj;
42787 fail:
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42793 PyObject *resultobj = 0;
42794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42795 bool result;
42796 void *argp1 = 0 ;
42797 int res1 = 0 ;
42798 PyObject *swig_obj[1] ;
42799
42800 if (!args) SWIG_fail;
42801 swig_obj[0] = args;
42802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42803 if (!SWIG_IsOK(res1)) {
42804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42805 }
42806 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 {
42814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42815 }
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj = 0;
42824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42825 bool arg2 = (bool) true ;
42826 void *argp1 = 0 ;
42827 int res1 = 0 ;
42828 bool val2 ;
42829 int ecode2 = 0 ;
42830 PyObject * obj0 = 0 ;
42831 PyObject * obj1 = 0 ;
42832 char * kwnames[] = {
42833 (char *) "self",(char *) "check", NULL
42834 };
42835
42836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42838 if (!SWIG_IsOK(res1)) {
42839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42840 }
42841 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42842 if (obj1) {
42843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42844 if (!SWIG_IsOK(ecode2)) {
42845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42846 }
42847 arg2 = static_cast< bool >(val2);
42848 }
42849 {
42850 PyThreadState* __tstate = wxPyBeginAllowThreads();
42851 (arg1)->Check(arg2);
42852 wxPyEndAllowThreads(__tstate);
42853 if (PyErr_Occurred()) SWIG_fail;
42854 }
42855 resultobj = SWIG_Py_Void();
42856 return resultobj;
42857 fail:
42858 return NULL;
42859 }
42860
42861
42862 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42863 PyObject *resultobj = 0;
42864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42865 bool result;
42866 void *argp1 = 0 ;
42867 int res1 = 0 ;
42868 PyObject *swig_obj[1] ;
42869
42870 if (!args) SWIG_fail;
42871 swig_obj[0] = args;
42872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42873 if (!SWIG_IsOK(res1)) {
42874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42875 }
42876 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42877 {
42878 PyThreadState* __tstate = wxPyBeginAllowThreads();
42879 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42880 wxPyEndAllowThreads(__tstate);
42881 if (PyErr_Occurred()) SWIG_fail;
42882 }
42883 {
42884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42885 }
42886 return resultobj;
42887 fail:
42888 return NULL;
42889 }
42890
42891
42892 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42893 PyObject *resultobj = 0;
42894 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42895 void *argp1 = 0 ;
42896 int res1 = 0 ;
42897 PyObject *swig_obj[1] ;
42898
42899 if (!args) SWIG_fail;
42900 swig_obj[0] = args;
42901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42902 if (!SWIG_IsOK(res1)) {
42903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42904 }
42905 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 (arg1)->Toggle();
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 resultobj = SWIG_Py_Void();
42913 return resultobj;
42914 fail:
42915 return NULL;
42916 }
42917
42918
42919 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42920 PyObject *resultobj = 0;
42921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42922 wxString *arg2 = 0 ;
42923 void *argp1 = 0 ;
42924 int res1 = 0 ;
42925 bool temp2 = false ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 char * kwnames[] = {
42929 (char *) "self",(char *) "str", NULL
42930 };
42931
42932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42934 if (!SWIG_IsOK(res1)) {
42935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42936 }
42937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42938 {
42939 arg2 = wxString_in_helper(obj1);
42940 if (arg2 == NULL) SWIG_fail;
42941 temp2 = true;
42942 }
42943 {
42944 PyThreadState* __tstate = wxPyBeginAllowThreads();
42945 (arg1)->SetHelp((wxString const &)*arg2);
42946 wxPyEndAllowThreads(__tstate);
42947 if (PyErr_Occurred()) SWIG_fail;
42948 }
42949 resultobj = SWIG_Py_Void();
42950 {
42951 if (temp2)
42952 delete arg2;
42953 }
42954 return resultobj;
42955 fail:
42956 {
42957 if (temp2)
42958 delete arg2;
42959 }
42960 return NULL;
42961 }
42962
42963
42964 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42965 PyObject *resultobj = 0;
42966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42967 wxString *result = 0 ;
42968 void *argp1 = 0 ;
42969 int res1 = 0 ;
42970 PyObject *swig_obj[1] ;
42971
42972 if (!args) SWIG_fail;
42973 swig_obj[0] = args;
42974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42975 if (!SWIG_IsOK(res1)) {
42976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42977 }
42978 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 {
42982 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42983 result = (wxString *) &_result_ref;
42984 }
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 {
42989 #if wxUSE_UNICODE
42990 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42991 #else
42992 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42993 #endif
42994 }
42995 return resultobj;
42996 fail:
42997 return NULL;
42998 }
42999
43000
43001 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43002 PyObject *resultobj = 0;
43003 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43004 wxAcceleratorEntry *result = 0 ;
43005 void *argp1 = 0 ;
43006 int res1 = 0 ;
43007 PyObject *swig_obj[1] ;
43008
43009 if (!args) SWIG_fail;
43010 swig_obj[0] = args;
43011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43012 if (!SWIG_IsOK(res1)) {
43013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43014 }
43015 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43016 {
43017 PyThreadState* __tstate = wxPyBeginAllowThreads();
43018 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43019 wxPyEndAllowThreads(__tstate);
43020 if (PyErr_Occurred()) SWIG_fail;
43021 }
43022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43030 PyObject *resultobj = 0;
43031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43032 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43033 void *argp1 = 0 ;
43034 int res1 = 0 ;
43035 void *argp2 = 0 ;
43036 int res2 = 0 ;
43037 PyObject * obj0 = 0 ;
43038 PyObject * obj1 = 0 ;
43039 char * kwnames[] = {
43040 (char *) "self",(char *) "accel", NULL
43041 };
43042
43043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43045 if (!SWIG_IsOK(res1)) {
43046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43047 }
43048 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43049 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43050 if (!SWIG_IsOK(res2)) {
43051 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43052 }
43053 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43054 {
43055 PyThreadState* __tstate = wxPyBeginAllowThreads();
43056 (arg1)->SetAccel(arg2);
43057 wxPyEndAllowThreads(__tstate);
43058 if (PyErr_Occurred()) SWIG_fail;
43059 }
43060 resultobj = SWIG_Py_Void();
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43068 PyObject *resultobj = 0;
43069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43070 wxBitmap *arg2 = 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 *) "bitmap", NULL
43079 };
43080
43081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",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_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43085 }
43086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43087 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43088 if (!SWIG_IsOK(res2)) {
43089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43090 }
43091 if (!argp2) {
43092 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43093 }
43094 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43095 {
43096 PyThreadState* __tstate = wxPyBeginAllowThreads();
43097 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43098 wxPyEndAllowThreads(__tstate);
43099 if (PyErr_Occurred()) SWIG_fail;
43100 }
43101 resultobj = SWIG_Py_Void();
43102 return resultobj;
43103 fail:
43104 return NULL;
43105 }
43106
43107
43108 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43109 PyObject *resultobj = 0;
43110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43111 wxBitmap *result = 0 ;
43112 void *argp1 = 0 ;
43113 int res1 = 0 ;
43114 PyObject *swig_obj[1] ;
43115
43116 if (!args) SWIG_fail;
43117 swig_obj[0] = args;
43118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43119 if (!SWIG_IsOK(res1)) {
43120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43121 }
43122 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43123 {
43124 PyThreadState* __tstate = wxPyBeginAllowThreads();
43125 {
43126 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43127 result = (wxBitmap *) &_result_ref;
43128 }
43129 wxPyEndAllowThreads(__tstate);
43130 if (PyErr_Occurred()) SWIG_fail;
43131 }
43132 {
43133 wxBitmap* resultptr = new wxBitmap(*result);
43134 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43135 }
43136 return resultobj;
43137 fail:
43138 return NULL;
43139 }
43140
43141
43142 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43143 PyObject *resultobj = 0;
43144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43145 wxFont *arg2 = 0 ;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 void *argp2 = 0 ;
43149 int res2 = 0 ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 char * kwnames[] = {
43153 (char *) "self",(char *) "font", NULL
43154 };
43155
43156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43158 if (!SWIG_IsOK(res1)) {
43159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43160 }
43161 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43162 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43163 if (!SWIG_IsOK(res2)) {
43164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43165 }
43166 if (!argp2) {
43167 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43168 }
43169 arg2 = reinterpret_cast< wxFont * >(argp2);
43170 {
43171 PyThreadState* __tstate = wxPyBeginAllowThreads();
43172 (arg1)->SetFont((wxFont const &)*arg2);
43173 wxPyEndAllowThreads(__tstate);
43174 if (PyErr_Occurred()) SWIG_fail;
43175 }
43176 resultobj = SWIG_Py_Void();
43177 return resultobj;
43178 fail:
43179 return NULL;
43180 }
43181
43182
43183 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43184 PyObject *resultobj = 0;
43185 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43186 wxFont result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 PyObject *swig_obj[1] ;
43190
43191 if (!args) SWIG_fail;
43192 swig_obj[0] = args;
43193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43194 if (!SWIG_IsOK(res1)) {
43195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43196 }
43197 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43198 {
43199 PyThreadState* __tstate = wxPyBeginAllowThreads();
43200 result = (arg1)->GetFont();
43201 wxPyEndAllowThreads(__tstate);
43202 if (PyErr_Occurred()) SWIG_fail;
43203 }
43204 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43205 return resultobj;
43206 fail:
43207 return NULL;
43208 }
43209
43210
43211 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43212 PyObject *resultobj = 0;
43213 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43214 wxColour *arg2 = 0 ;
43215 void *argp1 = 0 ;
43216 int res1 = 0 ;
43217 wxColour temp2 ;
43218 PyObject * obj0 = 0 ;
43219 PyObject * obj1 = 0 ;
43220 char * kwnames[] = {
43221 (char *) "self",(char *) "colText", NULL
43222 };
43223
43224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43226 if (!SWIG_IsOK(res1)) {
43227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43228 }
43229 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43230 {
43231 arg2 = &temp2;
43232 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43233 }
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 (arg1)->SetTextColour((wxColour const &)*arg2);
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 resultobj = SWIG_Py_Void();
43241 return resultobj;
43242 fail:
43243 return NULL;
43244 }
43245
43246
43247 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43248 PyObject *resultobj = 0;
43249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43250 wxColour result;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 PyObject *swig_obj[1] ;
43254
43255 if (!args) SWIG_fail;
43256 swig_obj[0] = args;
43257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43258 if (!SWIG_IsOK(res1)) {
43259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43260 }
43261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = (arg1)->GetTextColour();
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43269 return resultobj;
43270 fail:
43271 return NULL;
43272 }
43273
43274
43275 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43276 PyObject *resultobj = 0;
43277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43278 wxColour *arg2 = 0 ;
43279 void *argp1 = 0 ;
43280 int res1 = 0 ;
43281 wxColour temp2 ;
43282 PyObject * obj0 = 0 ;
43283 PyObject * obj1 = 0 ;
43284 char * kwnames[] = {
43285 (char *) "self",(char *) "colBack", NULL
43286 };
43287
43288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43290 if (!SWIG_IsOK(res1)) {
43291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43292 }
43293 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43294 {
43295 arg2 = &temp2;
43296 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43297 }
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43301 wxPyEndAllowThreads(__tstate);
43302 if (PyErr_Occurred()) SWIG_fail;
43303 }
43304 resultobj = SWIG_Py_Void();
43305 return resultobj;
43306 fail:
43307 return NULL;
43308 }
43309
43310
43311 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43312 PyObject *resultobj = 0;
43313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43314 wxColour result;
43315 void *argp1 = 0 ;
43316 int res1 = 0 ;
43317 PyObject *swig_obj[1] ;
43318
43319 if (!args) SWIG_fail;
43320 swig_obj[0] = args;
43321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43322 if (!SWIG_IsOK(res1)) {
43323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43324 }
43325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (arg1)->GetBackgroundColour();
43329 wxPyEndAllowThreads(__tstate);
43330 if (PyErr_Occurred()) SWIG_fail;
43331 }
43332 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43333 return resultobj;
43334 fail:
43335 return NULL;
43336 }
43337
43338
43339 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43340 PyObject *resultobj = 0;
43341 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43342 wxBitmap *arg2 = 0 ;
43343 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43344 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43345 void *argp1 = 0 ;
43346 int res1 = 0 ;
43347 void *argp2 = 0 ;
43348 int res2 = 0 ;
43349 void *argp3 = 0 ;
43350 int res3 = 0 ;
43351 PyObject * obj0 = 0 ;
43352 PyObject * obj1 = 0 ;
43353 PyObject * obj2 = 0 ;
43354 char * kwnames[] = {
43355 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43356 };
43357
43358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43360 if (!SWIG_IsOK(res1)) {
43361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43362 }
43363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43365 if (!SWIG_IsOK(res2)) {
43366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43367 }
43368 if (!argp2) {
43369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43370 }
43371 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43372 if (obj2) {
43373 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43374 if (!SWIG_IsOK(res3)) {
43375 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43376 }
43377 if (!argp3) {
43378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43379 }
43380 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43381 }
43382 {
43383 PyThreadState* __tstate = wxPyBeginAllowThreads();
43384 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43385 wxPyEndAllowThreads(__tstate);
43386 if (PyErr_Occurred()) SWIG_fail;
43387 }
43388 resultobj = SWIG_Py_Void();
43389 return resultobj;
43390 fail:
43391 return NULL;
43392 }
43393
43394
43395 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43396 PyObject *resultobj = 0;
43397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43398 wxBitmap *arg2 = 0 ;
43399 void *argp1 = 0 ;
43400 int res1 = 0 ;
43401 void *argp2 = 0 ;
43402 int res2 = 0 ;
43403 PyObject * obj0 = 0 ;
43404 PyObject * obj1 = 0 ;
43405 char * kwnames[] = {
43406 (char *) "self",(char *) "bmpDisabled", NULL
43407 };
43408
43409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43411 if (!SWIG_IsOK(res1)) {
43412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43413 }
43414 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43415 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43416 if (!SWIG_IsOK(res2)) {
43417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43418 }
43419 if (!argp2) {
43420 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43421 }
43422 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43423 {
43424 PyThreadState* __tstate = wxPyBeginAllowThreads();
43425 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43426 wxPyEndAllowThreads(__tstate);
43427 if (PyErr_Occurred()) SWIG_fail;
43428 }
43429 resultobj = SWIG_Py_Void();
43430 return resultobj;
43431 fail:
43432 return NULL;
43433 }
43434
43435
43436 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43437 PyObject *resultobj = 0;
43438 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43439 wxBitmap *result = 0 ;
43440 void *argp1 = 0 ;
43441 int res1 = 0 ;
43442 PyObject *swig_obj[1] ;
43443
43444 if (!args) SWIG_fail;
43445 swig_obj[0] = args;
43446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43447 if (!SWIG_IsOK(res1)) {
43448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43449 }
43450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43451 {
43452 PyThreadState* __tstate = wxPyBeginAllowThreads();
43453 {
43454 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43455 result = (wxBitmap *) &_result_ref;
43456 }
43457 wxPyEndAllowThreads(__tstate);
43458 if (PyErr_Occurred()) SWIG_fail;
43459 }
43460 {
43461 wxBitmap* resultptr = new wxBitmap(*result);
43462 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43463 }
43464 return resultobj;
43465 fail:
43466 return NULL;
43467 }
43468
43469
43470 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43471 PyObject *resultobj = 0;
43472 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43473 int arg2 ;
43474 void *argp1 = 0 ;
43475 int res1 = 0 ;
43476 int val2 ;
43477 int ecode2 = 0 ;
43478 PyObject * obj0 = 0 ;
43479 PyObject * obj1 = 0 ;
43480 char * kwnames[] = {
43481 (char *) "self",(char *) "nWidth", NULL
43482 };
43483
43484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43486 if (!SWIG_IsOK(res1)) {
43487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43488 }
43489 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43490 ecode2 = SWIG_AsVal_int(obj1, &val2);
43491 if (!SWIG_IsOK(ecode2)) {
43492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43493 }
43494 arg2 = static_cast< int >(val2);
43495 {
43496 PyThreadState* __tstate = wxPyBeginAllowThreads();
43497 (arg1)->SetMarginWidth(arg2);
43498 wxPyEndAllowThreads(__tstate);
43499 if (PyErr_Occurred()) SWIG_fail;
43500 }
43501 resultobj = SWIG_Py_Void();
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43509 PyObject *resultobj = 0;
43510 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43511 int result;
43512 void *argp1 = 0 ;
43513 int res1 = 0 ;
43514 PyObject *swig_obj[1] ;
43515
43516 if (!args) SWIG_fail;
43517 swig_obj[0] = args;
43518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43519 if (!SWIG_IsOK(res1)) {
43520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43521 }
43522 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43523 {
43524 PyThreadState* __tstate = wxPyBeginAllowThreads();
43525 result = (int)(arg1)->GetMarginWidth();
43526 wxPyEndAllowThreads(__tstate);
43527 if (PyErr_Occurred()) SWIG_fail;
43528 }
43529 resultobj = SWIG_From_int(static_cast< int >(result));
43530 return resultobj;
43531 fail:
43532 return NULL;
43533 }
43534
43535
43536 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43537 PyObject *resultobj = 0;
43538 int result;
43539
43540 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43541 {
43542 PyThreadState* __tstate = wxPyBeginAllowThreads();
43543 result = (int)wxMenuItem::GetDefaultMarginWidth();
43544 wxPyEndAllowThreads(__tstate);
43545 if (PyErr_Occurred()) SWIG_fail;
43546 }
43547 resultobj = SWIG_From_int(static_cast< int >(result));
43548 return resultobj;
43549 fail:
43550 return NULL;
43551 }
43552
43553
43554 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43555 PyObject *resultobj = 0;
43556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43557 bool result;
43558 void *argp1 = 0 ;
43559 int res1 = 0 ;
43560 PyObject *swig_obj[1] ;
43561
43562 if (!args) SWIG_fail;
43563 swig_obj[0] = args;
43564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43565 if (!SWIG_IsOK(res1)) {
43566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43567 }
43568 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43569 {
43570 PyThreadState* __tstate = wxPyBeginAllowThreads();
43571 result = (bool)(arg1)->IsOwnerDrawn();
43572 wxPyEndAllowThreads(__tstate);
43573 if (PyErr_Occurred()) SWIG_fail;
43574 }
43575 {
43576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43577 }
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43585 PyObject *resultobj = 0;
43586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43587 bool arg2 = (bool) true ;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 bool val2 ;
43591 int ecode2 = 0 ;
43592 PyObject * obj0 = 0 ;
43593 PyObject * obj1 = 0 ;
43594 char * kwnames[] = {
43595 (char *) "self",(char *) "ownerDrawn", NULL
43596 };
43597
43598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43600 if (!SWIG_IsOK(res1)) {
43601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43602 }
43603 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43604 if (obj1) {
43605 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43606 if (!SWIG_IsOK(ecode2)) {
43607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43608 }
43609 arg2 = static_cast< bool >(val2);
43610 }
43611 {
43612 PyThreadState* __tstate = wxPyBeginAllowThreads();
43613 (arg1)->SetOwnerDrawn(arg2);
43614 wxPyEndAllowThreads(__tstate);
43615 if (PyErr_Occurred()) SWIG_fail;
43616 }
43617 resultobj = SWIG_Py_Void();
43618 return resultobj;
43619 fail:
43620 return NULL;
43621 }
43622
43623
43624 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43625 PyObject *resultobj = 0;
43626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43627 void *argp1 = 0 ;
43628 int res1 = 0 ;
43629 PyObject *swig_obj[1] ;
43630
43631 if (!args) SWIG_fail;
43632 swig_obj[0] = args;
43633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43634 if (!SWIG_IsOK(res1)) {
43635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43636 }
43637 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43638 {
43639 PyThreadState* __tstate = wxPyBeginAllowThreads();
43640 (arg1)->ResetOwnerDrawn();
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 resultobj = SWIG_Py_Void();
43645 return resultobj;
43646 fail:
43647 return NULL;
43648 }
43649
43650
43651 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43652 PyObject *obj;
43653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43654 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43655 return SWIG_Py_Void();
43656 }
43657
43658 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43659 return SWIG_Python_InitShadowInstance(args);
43660 }
43661
43662 SWIGINTERN int ControlNameStr_set(PyObject *) {
43663 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43664 return 1;
43665 }
43666
43667
43668 SWIGINTERN PyObject *ControlNameStr_get(void) {
43669 PyObject *pyobj = 0;
43670
43671 {
43672 #if wxUSE_UNICODE
43673 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43674 #else
43675 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43676 #endif
43677 }
43678 return pyobj;
43679 }
43680
43681
43682 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43683 PyObject *resultobj = 0;
43684 wxWindow *arg1 = (wxWindow *) 0 ;
43685 int arg2 = (int) -1 ;
43686 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43687 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43688 wxSize const &arg4_defvalue = wxDefaultSize ;
43689 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43690 long arg5 = (long) 0 ;
43691 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43692 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43693 wxString const &arg7_defvalue = wxPyControlNameStr ;
43694 wxString *arg7 = (wxString *) &arg7_defvalue ;
43695 wxControl *result = 0 ;
43696 void *argp1 = 0 ;
43697 int res1 = 0 ;
43698 int val2 ;
43699 int ecode2 = 0 ;
43700 wxPoint temp3 ;
43701 wxSize temp4 ;
43702 long val5 ;
43703 int ecode5 = 0 ;
43704 void *argp6 = 0 ;
43705 int res6 = 0 ;
43706 bool temp7 = false ;
43707 PyObject * obj0 = 0 ;
43708 PyObject * obj1 = 0 ;
43709 PyObject * obj2 = 0 ;
43710 PyObject * obj3 = 0 ;
43711 PyObject * obj4 = 0 ;
43712 PyObject * obj5 = 0 ;
43713 PyObject * obj6 = 0 ;
43714 char * kwnames[] = {
43715 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43716 };
43717
43718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43720 if (!SWIG_IsOK(res1)) {
43721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43722 }
43723 arg1 = reinterpret_cast< wxWindow * >(argp1);
43724 if (obj1) {
43725 ecode2 = SWIG_AsVal_int(obj1, &val2);
43726 if (!SWIG_IsOK(ecode2)) {
43727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43728 }
43729 arg2 = static_cast< int >(val2);
43730 }
43731 if (obj2) {
43732 {
43733 arg3 = &temp3;
43734 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43735 }
43736 }
43737 if (obj3) {
43738 {
43739 arg4 = &temp4;
43740 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43741 }
43742 }
43743 if (obj4) {
43744 ecode5 = SWIG_AsVal_long(obj4, &val5);
43745 if (!SWIG_IsOK(ecode5)) {
43746 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43747 }
43748 arg5 = static_cast< long >(val5);
43749 }
43750 if (obj5) {
43751 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43752 if (!SWIG_IsOK(res6)) {
43753 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43754 }
43755 if (!argp6) {
43756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43757 }
43758 arg6 = reinterpret_cast< wxValidator * >(argp6);
43759 }
43760 if (obj6) {
43761 {
43762 arg7 = wxString_in_helper(obj6);
43763 if (arg7 == NULL) SWIG_fail;
43764 temp7 = true;
43765 }
43766 }
43767 {
43768 if (!wxPyCheckForApp()) SWIG_fail;
43769 PyThreadState* __tstate = wxPyBeginAllowThreads();
43770 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43771 wxPyEndAllowThreads(__tstate);
43772 if (PyErr_Occurred()) SWIG_fail;
43773 }
43774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43775 {
43776 if (temp7)
43777 delete arg7;
43778 }
43779 return resultobj;
43780 fail:
43781 {
43782 if (temp7)
43783 delete arg7;
43784 }
43785 return NULL;
43786 }
43787
43788
43789 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43790 PyObject *resultobj = 0;
43791 wxControl *result = 0 ;
43792
43793 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43794 {
43795 if (!wxPyCheckForApp()) SWIG_fail;
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 result = (wxControl *)new wxControl();
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43802 return resultobj;
43803 fail:
43804 return NULL;
43805 }
43806
43807
43808 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43809 PyObject *resultobj = 0;
43810 wxControl *arg1 = (wxControl *) 0 ;
43811 wxWindow *arg2 = (wxWindow *) 0 ;
43812 int arg3 = (int) -1 ;
43813 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43814 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43815 wxSize const &arg5_defvalue = wxDefaultSize ;
43816 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43817 long arg6 = (long) 0 ;
43818 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43819 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43820 wxString const &arg8_defvalue = wxPyControlNameStr ;
43821 wxString *arg8 = (wxString *) &arg8_defvalue ;
43822 bool result;
43823 void *argp1 = 0 ;
43824 int res1 = 0 ;
43825 void *argp2 = 0 ;
43826 int res2 = 0 ;
43827 int val3 ;
43828 int ecode3 = 0 ;
43829 wxPoint temp4 ;
43830 wxSize temp5 ;
43831 long val6 ;
43832 int ecode6 = 0 ;
43833 void *argp7 = 0 ;
43834 int res7 = 0 ;
43835 bool temp8 = false ;
43836 PyObject * obj0 = 0 ;
43837 PyObject * obj1 = 0 ;
43838 PyObject * obj2 = 0 ;
43839 PyObject * obj3 = 0 ;
43840 PyObject * obj4 = 0 ;
43841 PyObject * obj5 = 0 ;
43842 PyObject * obj6 = 0 ;
43843 PyObject * obj7 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43852 }
43853 arg1 = reinterpret_cast< wxControl * >(argp1);
43854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43855 if (!SWIG_IsOK(res2)) {
43856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43857 }
43858 arg2 = reinterpret_cast< wxWindow * >(argp2);
43859 if (obj2) {
43860 ecode3 = SWIG_AsVal_int(obj2, &val3);
43861 if (!SWIG_IsOK(ecode3)) {
43862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43863 }
43864 arg3 = static_cast< int >(val3);
43865 }
43866 if (obj3) {
43867 {
43868 arg4 = &temp4;
43869 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43870 }
43871 }
43872 if (obj4) {
43873 {
43874 arg5 = &temp5;
43875 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43876 }
43877 }
43878 if (obj5) {
43879 ecode6 = SWIG_AsVal_long(obj5, &val6);
43880 if (!SWIG_IsOK(ecode6)) {
43881 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43882 }
43883 arg6 = static_cast< long >(val6);
43884 }
43885 if (obj6) {
43886 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43887 if (!SWIG_IsOK(res7)) {
43888 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43889 }
43890 if (!argp7) {
43891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43892 }
43893 arg7 = reinterpret_cast< wxValidator * >(argp7);
43894 }
43895 if (obj7) {
43896 {
43897 arg8 = wxString_in_helper(obj7);
43898 if (arg8 == NULL) SWIG_fail;
43899 temp8 = true;
43900 }
43901 }
43902 {
43903 PyThreadState* __tstate = wxPyBeginAllowThreads();
43904 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43905 wxPyEndAllowThreads(__tstate);
43906 if (PyErr_Occurred()) SWIG_fail;
43907 }
43908 {
43909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43910 }
43911 {
43912 if (temp8)
43913 delete arg8;
43914 }
43915 return resultobj;
43916 fail:
43917 {
43918 if (temp8)
43919 delete arg8;
43920 }
43921 return NULL;
43922 }
43923
43924
43925 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43926 PyObject *resultobj = 0;
43927 wxControl *arg1 = (wxControl *) 0 ;
43928 wxCommandEvent *arg2 = 0 ;
43929 void *argp1 = 0 ;
43930 int res1 = 0 ;
43931 void *argp2 = 0 ;
43932 int res2 = 0 ;
43933 PyObject * obj0 = 0 ;
43934 PyObject * obj1 = 0 ;
43935 char * kwnames[] = {
43936 (char *) "self",(char *) "event", NULL
43937 };
43938
43939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43941 if (!SWIG_IsOK(res1)) {
43942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43943 }
43944 arg1 = reinterpret_cast< wxControl * >(argp1);
43945 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43946 if (!SWIG_IsOK(res2)) {
43947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43948 }
43949 if (!argp2) {
43950 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43951 }
43952 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43953 {
43954 PyThreadState* __tstate = wxPyBeginAllowThreads();
43955 (arg1)->Command(*arg2);
43956 wxPyEndAllowThreads(__tstate);
43957 if (PyErr_Occurred()) SWIG_fail;
43958 }
43959 resultobj = SWIG_Py_Void();
43960 return resultobj;
43961 fail:
43962 return NULL;
43963 }
43964
43965
43966 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43967 PyObject *resultobj = 0;
43968 wxControl *arg1 = (wxControl *) 0 ;
43969 wxString result;
43970 void *argp1 = 0 ;
43971 int res1 = 0 ;
43972 PyObject *swig_obj[1] ;
43973
43974 if (!args) SWIG_fail;
43975 swig_obj[0] = args;
43976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43977 if (!SWIG_IsOK(res1)) {
43978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43979 }
43980 arg1 = reinterpret_cast< wxControl * >(argp1);
43981 {
43982 PyThreadState* __tstate = wxPyBeginAllowThreads();
43983 result = (arg1)->GetLabel();
43984 wxPyEndAllowThreads(__tstate);
43985 if (PyErr_Occurred()) SWIG_fail;
43986 }
43987 {
43988 #if wxUSE_UNICODE
43989 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43990 #else
43991 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43992 #endif
43993 }
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44003 SwigValueWrapper<wxVisualAttributes > result;
44004 int val1 ;
44005 int ecode1 = 0 ;
44006 PyObject * obj0 = 0 ;
44007 char * kwnames[] = {
44008 (char *) "variant", NULL
44009 };
44010
44011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44012 if (obj0) {
44013 ecode1 = SWIG_AsVal_int(obj0, &val1);
44014 if (!SWIG_IsOK(ecode1)) {
44015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44016 }
44017 arg1 = static_cast< wxWindowVariant >(val1);
44018 }
44019 {
44020 if (!wxPyCheckForApp()) SWIG_fail;
44021 PyThreadState* __tstate = wxPyBeginAllowThreads();
44022 result = wxControl::GetClassDefaultAttributes(arg1);
44023 wxPyEndAllowThreads(__tstate);
44024 if (PyErr_Occurred()) SWIG_fail;
44025 }
44026 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44027 return resultobj;
44028 fail:
44029 return NULL;
44030 }
44031
44032
44033 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44034 PyObject *obj;
44035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44036 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44037 return SWIG_Py_Void();
44038 }
44039
44040 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44041 return SWIG_Python_InitShadowInstance(args);
44042 }
44043
44044 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44045 PyObject *resultobj = 0;
44046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44047 wxString *arg2 = 0 ;
44048 PyObject *arg3 = (PyObject *) NULL ;
44049 int result;
44050 void *argp1 = 0 ;
44051 int res1 = 0 ;
44052 bool temp2 = false ;
44053 PyObject * obj0 = 0 ;
44054 PyObject * obj1 = 0 ;
44055 PyObject * obj2 = 0 ;
44056 char * kwnames[] = {
44057 (char *) "self",(char *) "item",(char *) "clientData", NULL
44058 };
44059
44060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44062 if (!SWIG_IsOK(res1)) {
44063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44064 }
44065 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44066 {
44067 arg2 = wxString_in_helper(obj1);
44068 if (arg2 == NULL) SWIG_fail;
44069 temp2 = true;
44070 }
44071 if (obj2) {
44072 arg3 = obj2;
44073 }
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44077 wxPyEndAllowThreads(__tstate);
44078 if (PyErr_Occurred()) SWIG_fail;
44079 }
44080 resultobj = SWIG_From_int(static_cast< int >(result));
44081 {
44082 if (temp2)
44083 delete arg2;
44084 }
44085 return resultobj;
44086 fail:
44087 {
44088 if (temp2)
44089 delete arg2;
44090 }
44091 return NULL;
44092 }
44093
44094
44095 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44096 PyObject *resultobj = 0;
44097 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44098 wxArrayString *arg2 = 0 ;
44099 void *argp1 = 0 ;
44100 int res1 = 0 ;
44101 bool temp2 = false ;
44102 PyObject * obj0 = 0 ;
44103 PyObject * obj1 = 0 ;
44104 char * kwnames[] = {
44105 (char *) "self",(char *) "strings", NULL
44106 };
44107
44108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44110 if (!SWIG_IsOK(res1)) {
44111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44112 }
44113 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44114 {
44115 if (! PySequence_Check(obj1)) {
44116 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44117 SWIG_fail;
44118 }
44119 arg2 = new wxArrayString;
44120 temp2 = true;
44121 int i, len=PySequence_Length(obj1);
44122 for (i=0; i<len; i++) {
44123 PyObject* item = PySequence_GetItem(obj1, i);
44124 wxString* s = wxString_in_helper(item);
44125 if (PyErr_Occurred()) SWIG_fail;
44126 arg2->Add(*s);
44127 delete s;
44128 Py_DECREF(item);
44129 }
44130 }
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 (arg1)->Append((wxArrayString const &)*arg2);
44134 wxPyEndAllowThreads(__tstate);
44135 if (PyErr_Occurred()) SWIG_fail;
44136 }
44137 resultobj = SWIG_Py_Void();
44138 {
44139 if (temp2) delete arg2;
44140 }
44141 return resultobj;
44142 fail:
44143 {
44144 if (temp2) delete arg2;
44145 }
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44153 wxString *arg2 = 0 ;
44154 unsigned int arg3 ;
44155 PyObject *arg4 = (PyObject *) NULL ;
44156 int result;
44157 void *argp1 = 0 ;
44158 int res1 = 0 ;
44159 bool temp2 = false ;
44160 unsigned int val3 ;
44161 int ecode3 = 0 ;
44162 PyObject * obj0 = 0 ;
44163 PyObject * obj1 = 0 ;
44164 PyObject * obj2 = 0 ;
44165 PyObject * obj3 = 0 ;
44166 char * kwnames[] = {
44167 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44168 };
44169
44170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44172 if (!SWIG_IsOK(res1)) {
44173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44174 }
44175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44176 {
44177 arg2 = wxString_in_helper(obj1);
44178 if (arg2 == NULL) SWIG_fail;
44179 temp2 = true;
44180 }
44181 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44182 if (!SWIG_IsOK(ecode3)) {
44183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44184 }
44185 arg3 = static_cast< unsigned int >(val3);
44186 if (obj3) {
44187 arg4 = obj3;
44188 }
44189 {
44190 PyThreadState* __tstate = wxPyBeginAllowThreads();
44191 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44192 wxPyEndAllowThreads(__tstate);
44193 if (PyErr_Occurred()) SWIG_fail;
44194 }
44195 resultobj = SWIG_From_int(static_cast< int >(result));
44196 {
44197 if (temp2)
44198 delete arg2;
44199 }
44200 return resultobj;
44201 fail:
44202 {
44203 if (temp2)
44204 delete arg2;
44205 }
44206 return NULL;
44207 }
44208
44209
44210 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44211 PyObject *resultobj = 0;
44212 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44213 void *argp1 = 0 ;
44214 int res1 = 0 ;
44215 PyObject *swig_obj[1] ;
44216
44217 if (!args) SWIG_fail;
44218 swig_obj[0] = args;
44219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44220 if (!SWIG_IsOK(res1)) {
44221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44222 }
44223 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44224 {
44225 PyThreadState* __tstate = wxPyBeginAllowThreads();
44226 (arg1)->Clear();
44227 wxPyEndAllowThreads(__tstate);
44228 if (PyErr_Occurred()) SWIG_fail;
44229 }
44230 resultobj = SWIG_Py_Void();
44231 return resultobj;
44232 fail:
44233 return NULL;
44234 }
44235
44236
44237 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44238 PyObject *resultobj = 0;
44239 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44240 unsigned int arg2 ;
44241 void *argp1 = 0 ;
44242 int res1 = 0 ;
44243 unsigned int val2 ;
44244 int ecode2 = 0 ;
44245 PyObject * obj0 = 0 ;
44246 PyObject * obj1 = 0 ;
44247 char * kwnames[] = {
44248 (char *) "self",(char *) "n", NULL
44249 };
44250
44251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44253 if (!SWIG_IsOK(res1)) {
44254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44255 }
44256 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44257 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44258 if (!SWIG_IsOK(ecode2)) {
44259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44260 }
44261 arg2 = static_cast< unsigned int >(val2);
44262 {
44263 PyThreadState* __tstate = wxPyBeginAllowThreads();
44264 (arg1)->Delete(arg2);
44265 wxPyEndAllowThreads(__tstate);
44266 if (PyErr_Occurred()) SWIG_fail;
44267 }
44268 resultobj = SWIG_Py_Void();
44269 return resultobj;
44270 fail:
44271 return NULL;
44272 }
44273
44274
44275 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44276 PyObject *resultobj = 0;
44277 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44278 unsigned int arg2 ;
44279 PyObject *result = 0 ;
44280 void *argp1 = 0 ;
44281 int res1 = 0 ;
44282 unsigned int val2 ;
44283 int ecode2 = 0 ;
44284 PyObject * obj0 = 0 ;
44285 PyObject * obj1 = 0 ;
44286 char * kwnames[] = {
44287 (char *) "self",(char *) "n", NULL
44288 };
44289
44290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44292 if (!SWIG_IsOK(res1)) {
44293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44294 }
44295 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44296 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44297 if (!SWIG_IsOK(ecode2)) {
44298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44299 }
44300 arg2 = static_cast< unsigned int >(val2);
44301 {
44302 PyThreadState* __tstate = wxPyBeginAllowThreads();
44303 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44304 wxPyEndAllowThreads(__tstate);
44305 if (PyErr_Occurred()) SWIG_fail;
44306 }
44307 resultobj = result;
44308 return resultobj;
44309 fail:
44310 return NULL;
44311 }
44312
44313
44314 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44315 PyObject *resultobj = 0;
44316 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44317 unsigned int arg2 ;
44318 PyObject *arg3 = (PyObject *) 0 ;
44319 void *argp1 = 0 ;
44320 int res1 = 0 ;
44321 unsigned int val2 ;
44322 int ecode2 = 0 ;
44323 PyObject * obj0 = 0 ;
44324 PyObject * obj1 = 0 ;
44325 PyObject * obj2 = 0 ;
44326 char * kwnames[] = {
44327 (char *) "self",(char *) "n",(char *) "clientData", NULL
44328 };
44329
44330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44332 if (!SWIG_IsOK(res1)) {
44333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44334 }
44335 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44336 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44337 if (!SWIG_IsOK(ecode2)) {
44338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44339 }
44340 arg2 = static_cast< unsigned int >(val2);
44341 arg3 = obj2;
44342 {
44343 PyThreadState* __tstate = wxPyBeginAllowThreads();
44344 wxItemContainer_SetClientData(arg1,arg2,arg3);
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_Py_Void();
44349 return resultobj;
44350 fail:
44351 return NULL;
44352 }
44353
44354
44355 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44356 PyObject *resultobj = 0;
44357 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44358 unsigned int result;
44359 void *argp1 = 0 ;
44360 int res1 = 0 ;
44361 PyObject *swig_obj[1] ;
44362
44363 if (!args) SWIG_fail;
44364 swig_obj[0] = args;
44365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44366 if (!SWIG_IsOK(res1)) {
44367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44368 }
44369 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44373 wxPyEndAllowThreads(__tstate);
44374 if (PyErr_Occurred()) SWIG_fail;
44375 }
44376 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44377 return resultobj;
44378 fail:
44379 return NULL;
44380 }
44381
44382
44383 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44384 PyObject *resultobj = 0;
44385 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44386 bool result;
44387 void *argp1 = 0 ;
44388 int res1 = 0 ;
44389 PyObject *swig_obj[1] ;
44390
44391 if (!args) SWIG_fail;
44392 swig_obj[0] = args;
44393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44394 if (!SWIG_IsOK(res1)) {
44395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44396 }
44397 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44401 wxPyEndAllowThreads(__tstate);
44402 if (PyErr_Occurred()) SWIG_fail;
44403 }
44404 {
44405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44406 }
44407 return resultobj;
44408 fail:
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44414 PyObject *resultobj = 0;
44415 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44416 unsigned int arg2 ;
44417 wxString result;
44418 void *argp1 = 0 ;
44419 int res1 = 0 ;
44420 unsigned int val2 ;
44421 int ecode2 = 0 ;
44422 PyObject * obj0 = 0 ;
44423 PyObject * obj1 = 0 ;
44424 char * kwnames[] = {
44425 (char *) "self",(char *) "n", NULL
44426 };
44427
44428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44430 if (!SWIG_IsOK(res1)) {
44431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44432 }
44433 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44434 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44435 if (!SWIG_IsOK(ecode2)) {
44436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44437 }
44438 arg2 = static_cast< unsigned int >(val2);
44439 {
44440 PyThreadState* __tstate = wxPyBeginAllowThreads();
44441 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44442 wxPyEndAllowThreads(__tstate);
44443 if (PyErr_Occurred()) SWIG_fail;
44444 }
44445 {
44446 #if wxUSE_UNICODE
44447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44448 #else
44449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44450 #endif
44451 }
44452 return resultobj;
44453 fail:
44454 return NULL;
44455 }
44456
44457
44458 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44459 PyObject *resultobj = 0;
44460 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44461 wxArrayString result;
44462 void *argp1 = 0 ;
44463 int res1 = 0 ;
44464 PyObject *swig_obj[1] ;
44465
44466 if (!args) SWIG_fail;
44467 swig_obj[0] = args;
44468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44469 if (!SWIG_IsOK(res1)) {
44470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44471 }
44472 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44473 {
44474 PyThreadState* __tstate = wxPyBeginAllowThreads();
44475 result = ((wxItemContainer const *)arg1)->GetStrings();
44476 wxPyEndAllowThreads(__tstate);
44477 if (PyErr_Occurred()) SWIG_fail;
44478 }
44479 {
44480 resultobj = wxArrayString2PyList_helper(result);
44481 }
44482 return resultobj;
44483 fail:
44484 return NULL;
44485 }
44486
44487
44488 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44489 PyObject *resultobj = 0;
44490 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44491 unsigned int arg2 ;
44492 wxString *arg3 = 0 ;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 unsigned int val2 ;
44496 int ecode2 = 0 ;
44497 bool temp3 = false ;
44498 PyObject * obj0 = 0 ;
44499 PyObject * obj1 = 0 ;
44500 PyObject * obj2 = 0 ;
44501 char * kwnames[] = {
44502 (char *) "self",(char *) "n",(char *) "s", NULL
44503 };
44504
44505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44507 if (!SWIG_IsOK(res1)) {
44508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44509 }
44510 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44511 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44512 if (!SWIG_IsOK(ecode2)) {
44513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44514 }
44515 arg2 = static_cast< unsigned int >(val2);
44516 {
44517 arg3 = wxString_in_helper(obj2);
44518 if (arg3 == NULL) SWIG_fail;
44519 temp3 = true;
44520 }
44521 {
44522 PyThreadState* __tstate = wxPyBeginAllowThreads();
44523 (arg1)->SetString(arg2,(wxString const &)*arg3);
44524 wxPyEndAllowThreads(__tstate);
44525 if (PyErr_Occurred()) SWIG_fail;
44526 }
44527 resultobj = SWIG_Py_Void();
44528 {
44529 if (temp3)
44530 delete arg3;
44531 }
44532 return resultobj;
44533 fail:
44534 {
44535 if (temp3)
44536 delete arg3;
44537 }
44538 return NULL;
44539 }
44540
44541
44542 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44543 PyObject *resultobj = 0;
44544 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44545 wxString *arg2 = 0 ;
44546 int result;
44547 void *argp1 = 0 ;
44548 int res1 = 0 ;
44549 bool temp2 = false ;
44550 PyObject * obj0 = 0 ;
44551 PyObject * obj1 = 0 ;
44552 char * kwnames[] = {
44553 (char *) "self",(char *) "s", NULL
44554 };
44555
44556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44558 if (!SWIG_IsOK(res1)) {
44559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44560 }
44561 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44562 {
44563 arg2 = wxString_in_helper(obj1);
44564 if (arg2 == NULL) SWIG_fail;
44565 temp2 = true;
44566 }
44567 {
44568 PyThreadState* __tstate = wxPyBeginAllowThreads();
44569 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44570 wxPyEndAllowThreads(__tstate);
44571 if (PyErr_Occurred()) SWIG_fail;
44572 }
44573 resultobj = SWIG_From_int(static_cast< int >(result));
44574 {
44575 if (temp2)
44576 delete arg2;
44577 }
44578 return resultobj;
44579 fail:
44580 {
44581 if (temp2)
44582 delete arg2;
44583 }
44584 return NULL;
44585 }
44586
44587
44588 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44589 PyObject *resultobj = 0;
44590 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44591 int arg2 ;
44592 void *argp1 = 0 ;
44593 int res1 = 0 ;
44594 int val2 ;
44595 int ecode2 = 0 ;
44596 PyObject * obj0 = 0 ;
44597 PyObject * obj1 = 0 ;
44598 char * kwnames[] = {
44599 (char *) "self",(char *) "n", NULL
44600 };
44601
44602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44604 if (!SWIG_IsOK(res1)) {
44605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44606 }
44607 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44608 ecode2 = SWIG_AsVal_int(obj1, &val2);
44609 if (!SWIG_IsOK(ecode2)) {
44610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44611 }
44612 arg2 = static_cast< int >(val2);
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 (arg1)->SetSelection(arg2);
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 resultobj = SWIG_Py_Void();
44620 return resultobj;
44621 fail:
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44627 PyObject *resultobj = 0;
44628 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44629 int result;
44630 void *argp1 = 0 ;
44631 int res1 = 0 ;
44632 PyObject *swig_obj[1] ;
44633
44634 if (!args) SWIG_fail;
44635 swig_obj[0] = args;
44636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44637 if (!SWIG_IsOK(res1)) {
44638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44639 }
44640 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44641 {
44642 PyThreadState* __tstate = wxPyBeginAllowThreads();
44643 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 resultobj = SWIG_From_int(static_cast< int >(result));
44648 return resultobj;
44649 fail:
44650 return NULL;
44651 }
44652
44653
44654 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44655 PyObject *resultobj = 0;
44656 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44657 wxString *arg2 = 0 ;
44658 bool result;
44659 void *argp1 = 0 ;
44660 int res1 = 0 ;
44661 bool temp2 = false ;
44662 PyObject * obj0 = 0 ;
44663 PyObject * obj1 = 0 ;
44664 char * kwnames[] = {
44665 (char *) "self",(char *) "s", NULL
44666 };
44667
44668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44670 if (!SWIG_IsOK(res1)) {
44671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44672 }
44673 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44674 {
44675 arg2 = wxString_in_helper(obj1);
44676 if (arg2 == NULL) SWIG_fail;
44677 temp2 = true;
44678 }
44679 {
44680 PyThreadState* __tstate = wxPyBeginAllowThreads();
44681 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44682 wxPyEndAllowThreads(__tstate);
44683 if (PyErr_Occurred()) SWIG_fail;
44684 }
44685 {
44686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44687 }
44688 {
44689 if (temp2)
44690 delete arg2;
44691 }
44692 return resultobj;
44693 fail:
44694 {
44695 if (temp2)
44696 delete arg2;
44697 }
44698 return NULL;
44699 }
44700
44701
44702 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44703 PyObject *resultobj = 0;
44704 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44705 wxString result;
44706 void *argp1 = 0 ;
44707 int res1 = 0 ;
44708 PyObject *swig_obj[1] ;
44709
44710 if (!args) SWIG_fail;
44711 swig_obj[0] = args;
44712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44713 if (!SWIG_IsOK(res1)) {
44714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44715 }
44716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 {
44724 #if wxUSE_UNICODE
44725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44726 #else
44727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44728 #endif
44729 }
44730 return resultobj;
44731 fail:
44732 return NULL;
44733 }
44734
44735
44736 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44737 PyObject *resultobj = 0;
44738 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44739 int arg2 ;
44740 void *argp1 = 0 ;
44741 int res1 = 0 ;
44742 int val2 ;
44743 int ecode2 = 0 ;
44744 PyObject * obj0 = 0 ;
44745 PyObject * obj1 = 0 ;
44746 char * kwnames[] = {
44747 (char *) "self",(char *) "n", NULL
44748 };
44749
44750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44752 if (!SWIG_IsOK(res1)) {
44753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44754 }
44755 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44756 ecode2 = SWIG_AsVal_int(obj1, &val2);
44757 if (!SWIG_IsOK(ecode2)) {
44758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44759 }
44760 arg2 = static_cast< int >(val2);
44761 {
44762 PyThreadState* __tstate = wxPyBeginAllowThreads();
44763 (arg1)->Select(arg2);
44764 wxPyEndAllowThreads(__tstate);
44765 if (PyErr_Occurred()) SWIG_fail;
44766 }
44767 resultobj = SWIG_Py_Void();
44768 return resultobj;
44769 fail:
44770 return NULL;
44771 }
44772
44773
44774 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44775 PyObject *obj;
44776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44777 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44778 return SWIG_Py_Void();
44779 }
44780
44781 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44782 PyObject *obj;
44783 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44784 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44785 return SWIG_Py_Void();
44786 }
44787
44788 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44789 PyObject *resultobj = 0;
44790 wxSizerItem *result = 0 ;
44791
44792 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44793 {
44794 PyThreadState* __tstate = wxPyBeginAllowThreads();
44795 result = (wxSizerItem *)new wxSizerItem();
44796 wxPyEndAllowThreads(__tstate);
44797 if (PyErr_Occurred()) SWIG_fail;
44798 }
44799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44800 return resultobj;
44801 fail:
44802 return NULL;
44803 }
44804
44805
44806 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44807 PyObject *resultobj = 0;
44808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44809 void *argp1 = 0 ;
44810 int res1 = 0 ;
44811 PyObject *swig_obj[1] ;
44812
44813 if (!args) SWIG_fail;
44814 swig_obj[0] = args;
44815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44816 if (!SWIG_IsOK(res1)) {
44817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44818 }
44819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44820 {
44821 PyThreadState* __tstate = wxPyBeginAllowThreads();
44822 delete arg1;
44823
44824 wxPyEndAllowThreads(__tstate);
44825 if (PyErr_Occurred()) SWIG_fail;
44826 }
44827 resultobj = SWIG_Py_Void();
44828 return resultobj;
44829 fail:
44830 return NULL;
44831 }
44832
44833
44834 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44835 PyObject *resultobj = 0;
44836 wxWindow *arg1 = (wxWindow *) 0 ;
44837 int arg2 ;
44838 int arg3 ;
44839 int arg4 ;
44840 PyObject *arg5 = (PyObject *) NULL ;
44841 wxSizerItem *result = 0 ;
44842 void *argp1 = 0 ;
44843 int res1 = 0 ;
44844 int val2 ;
44845 int ecode2 = 0 ;
44846 int val3 ;
44847 int ecode3 = 0 ;
44848 int val4 ;
44849 int ecode4 = 0 ;
44850 PyObject * obj0 = 0 ;
44851 PyObject * obj1 = 0 ;
44852 PyObject * obj2 = 0 ;
44853 PyObject * obj3 = 0 ;
44854 PyObject * obj4 = 0 ;
44855 char * kwnames[] = {
44856 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44857 };
44858
44859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44861 if (!SWIG_IsOK(res1)) {
44862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44863 }
44864 arg1 = reinterpret_cast< wxWindow * >(argp1);
44865 ecode2 = SWIG_AsVal_int(obj1, &val2);
44866 if (!SWIG_IsOK(ecode2)) {
44867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44868 }
44869 arg2 = static_cast< int >(val2);
44870 ecode3 = SWIG_AsVal_int(obj2, &val3);
44871 if (!SWIG_IsOK(ecode3)) {
44872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44873 }
44874 arg3 = static_cast< int >(val3);
44875 ecode4 = SWIG_AsVal_int(obj3, &val4);
44876 if (!SWIG_IsOK(ecode4)) {
44877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44878 }
44879 arg4 = static_cast< int >(val4);
44880 if (obj4) {
44881 arg5 = obj4;
44882 }
44883 {
44884 PyThreadState* __tstate = wxPyBeginAllowThreads();
44885 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44886 wxPyEndAllowThreads(__tstate);
44887 if (PyErr_Occurred()) SWIG_fail;
44888 }
44889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44890 return resultobj;
44891 fail:
44892 return NULL;
44893 }
44894
44895
44896 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44897 PyObject *resultobj = 0;
44898 int arg1 ;
44899 int arg2 ;
44900 int arg3 ;
44901 int arg4 ;
44902 int arg5 ;
44903 PyObject *arg6 = (PyObject *) NULL ;
44904 wxSizerItem *result = 0 ;
44905 int val1 ;
44906 int ecode1 = 0 ;
44907 int val2 ;
44908 int ecode2 = 0 ;
44909 int val3 ;
44910 int ecode3 = 0 ;
44911 int val4 ;
44912 int ecode4 = 0 ;
44913 int val5 ;
44914 int ecode5 = 0 ;
44915 PyObject * obj0 = 0 ;
44916 PyObject * obj1 = 0 ;
44917 PyObject * obj2 = 0 ;
44918 PyObject * obj3 = 0 ;
44919 PyObject * obj4 = 0 ;
44920 PyObject * obj5 = 0 ;
44921 char * kwnames[] = {
44922 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44923 };
44924
44925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44926 ecode1 = SWIG_AsVal_int(obj0, &val1);
44927 if (!SWIG_IsOK(ecode1)) {
44928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44929 }
44930 arg1 = static_cast< int >(val1);
44931 ecode2 = SWIG_AsVal_int(obj1, &val2);
44932 if (!SWIG_IsOK(ecode2)) {
44933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44934 }
44935 arg2 = static_cast< int >(val2);
44936 ecode3 = SWIG_AsVal_int(obj2, &val3);
44937 if (!SWIG_IsOK(ecode3)) {
44938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44939 }
44940 arg3 = static_cast< int >(val3);
44941 ecode4 = SWIG_AsVal_int(obj3, &val4);
44942 if (!SWIG_IsOK(ecode4)) {
44943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44944 }
44945 arg4 = static_cast< int >(val4);
44946 ecode5 = SWIG_AsVal_int(obj4, &val5);
44947 if (!SWIG_IsOK(ecode5)) {
44948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44949 }
44950 arg5 = static_cast< int >(val5);
44951 if (obj5) {
44952 arg6 = obj5;
44953 }
44954 {
44955 PyThreadState* __tstate = wxPyBeginAllowThreads();
44956 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44961 return resultobj;
44962 fail:
44963 return NULL;
44964 }
44965
44966
44967 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44968 PyObject *resultobj = 0;
44969 wxSizer *arg1 = (wxSizer *) 0 ;
44970 int arg2 ;
44971 int arg3 ;
44972 int arg4 ;
44973 PyObject *arg5 = (PyObject *) NULL ;
44974 wxSizerItem *result = 0 ;
44975 int res1 = 0 ;
44976 int val2 ;
44977 int ecode2 = 0 ;
44978 int val3 ;
44979 int ecode3 = 0 ;
44980 int val4 ;
44981 int ecode4 = 0 ;
44982 PyObject * obj0 = 0 ;
44983 PyObject * obj1 = 0 ;
44984 PyObject * obj2 = 0 ;
44985 PyObject * obj3 = 0 ;
44986 PyObject * obj4 = 0 ;
44987 char * kwnames[] = {
44988 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44989 };
44990
44991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44992 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44995 }
44996 ecode2 = SWIG_AsVal_int(obj1, &val2);
44997 if (!SWIG_IsOK(ecode2)) {
44998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44999 }
45000 arg2 = static_cast< int >(val2);
45001 ecode3 = SWIG_AsVal_int(obj2, &val3);
45002 if (!SWIG_IsOK(ecode3)) {
45003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45004 }
45005 arg3 = static_cast< int >(val3);
45006 ecode4 = SWIG_AsVal_int(obj3, &val4);
45007 if (!SWIG_IsOK(ecode4)) {
45008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45009 }
45010 arg4 = static_cast< int >(val4);
45011 if (obj4) {
45012 arg5 = obj4;
45013 }
45014 {
45015 PyThreadState* __tstate = wxPyBeginAllowThreads();
45016 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45017 wxPyEndAllowThreads(__tstate);
45018 if (PyErr_Occurred()) SWIG_fail;
45019 }
45020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45021 return resultobj;
45022 fail:
45023 return NULL;
45024 }
45025
45026
45027 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45028 PyObject *resultobj = 0;
45029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45030 void *argp1 = 0 ;
45031 int res1 = 0 ;
45032 PyObject *swig_obj[1] ;
45033
45034 if (!args) SWIG_fail;
45035 swig_obj[0] = args;
45036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45037 if (!SWIG_IsOK(res1)) {
45038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45039 }
45040 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45041 {
45042 PyThreadState* __tstate = wxPyBeginAllowThreads();
45043 (arg1)->DeleteWindows();
45044 wxPyEndAllowThreads(__tstate);
45045 if (PyErr_Occurred()) SWIG_fail;
45046 }
45047 resultobj = SWIG_Py_Void();
45048 return resultobj;
45049 fail:
45050 return NULL;
45051 }
45052
45053
45054 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45055 PyObject *resultobj = 0;
45056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45057 void *argp1 = 0 ;
45058 int res1 = 0 ;
45059 PyObject *swig_obj[1] ;
45060
45061 if (!args) SWIG_fail;
45062 swig_obj[0] = args;
45063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45064 if (!SWIG_IsOK(res1)) {
45065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45066 }
45067 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45068 {
45069 PyThreadState* __tstate = wxPyBeginAllowThreads();
45070 (arg1)->DetachSizer();
45071 wxPyEndAllowThreads(__tstate);
45072 if (PyErr_Occurred()) SWIG_fail;
45073 }
45074 resultobj = SWIG_Py_Void();
45075 return resultobj;
45076 fail:
45077 return NULL;
45078 }
45079
45080
45081 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45082 PyObject *resultobj = 0;
45083 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45084 wxSize result;
45085 void *argp1 = 0 ;
45086 int res1 = 0 ;
45087 PyObject *swig_obj[1] ;
45088
45089 if (!args) SWIG_fail;
45090 swig_obj[0] = args;
45091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45092 if (!SWIG_IsOK(res1)) {
45093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45094 }
45095 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45096 {
45097 PyThreadState* __tstate = wxPyBeginAllowThreads();
45098 result = (arg1)->GetSize();
45099 wxPyEndAllowThreads(__tstate);
45100 if (PyErr_Occurred()) SWIG_fail;
45101 }
45102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45103 return resultobj;
45104 fail:
45105 return NULL;
45106 }
45107
45108
45109 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45110 PyObject *resultobj = 0;
45111 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45112 wxSize result;
45113 void *argp1 = 0 ;
45114 int res1 = 0 ;
45115 PyObject *swig_obj[1] ;
45116
45117 if (!args) SWIG_fail;
45118 swig_obj[0] = args;
45119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45120 if (!SWIG_IsOK(res1)) {
45121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45122 }
45123 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45124 {
45125 PyThreadState* __tstate = wxPyBeginAllowThreads();
45126 result = (arg1)->CalcMin();
45127 wxPyEndAllowThreads(__tstate);
45128 if (PyErr_Occurred()) SWIG_fail;
45129 }
45130 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45131 return resultobj;
45132 fail:
45133 return NULL;
45134 }
45135
45136
45137 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45138 PyObject *resultobj = 0;
45139 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45140 wxPoint *arg2 = 0 ;
45141 wxSize *arg3 = 0 ;
45142 void *argp1 = 0 ;
45143 int res1 = 0 ;
45144 wxPoint temp2 ;
45145 wxSize temp3 ;
45146 PyObject * obj0 = 0 ;
45147 PyObject * obj1 = 0 ;
45148 PyObject * obj2 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "self",(char *) "pos",(char *) "size", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45157 }
45158 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45159 {
45160 arg2 = &temp2;
45161 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45162 }
45163 {
45164 arg3 = &temp3;
45165 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45166 }
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45170 wxPyEndAllowThreads(__tstate);
45171 if (PyErr_Occurred()) SWIG_fail;
45172 }
45173 resultobj = SWIG_Py_Void();
45174 return resultobj;
45175 fail:
45176 return NULL;
45177 }
45178
45179
45180 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45181 PyObject *resultobj = 0;
45182 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45183 wxSize result;
45184 void *argp1 = 0 ;
45185 int res1 = 0 ;
45186 PyObject *swig_obj[1] ;
45187
45188 if (!args) SWIG_fail;
45189 swig_obj[0] = args;
45190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45191 if (!SWIG_IsOK(res1)) {
45192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45193 }
45194 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45195 {
45196 PyThreadState* __tstate = wxPyBeginAllowThreads();
45197 result = (arg1)->GetMinSize();
45198 wxPyEndAllowThreads(__tstate);
45199 if (PyErr_Occurred()) SWIG_fail;
45200 }
45201 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45202 return resultobj;
45203 fail:
45204 return NULL;
45205 }
45206
45207
45208 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45209 PyObject *resultobj = 0;
45210 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45211 wxSize result;
45212 void *argp1 = 0 ;
45213 int res1 = 0 ;
45214 PyObject *swig_obj[1] ;
45215
45216 if (!args) SWIG_fail;
45217 swig_obj[0] = args;
45218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45219 if (!SWIG_IsOK(res1)) {
45220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45221 }
45222 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45223 {
45224 PyThreadState* __tstate = wxPyBeginAllowThreads();
45225 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45226 wxPyEndAllowThreads(__tstate);
45227 if (PyErr_Occurred()) SWIG_fail;
45228 }
45229 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45230 return resultobj;
45231 fail:
45232 return NULL;
45233 }
45234
45235
45236 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45237 PyObject *resultobj = 0;
45238 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45239 int arg2 ;
45240 int arg3 ;
45241 void *argp1 = 0 ;
45242 int res1 = 0 ;
45243 int val2 ;
45244 int ecode2 = 0 ;
45245 int val3 ;
45246 int ecode3 = 0 ;
45247 PyObject * obj0 = 0 ;
45248 PyObject * obj1 = 0 ;
45249 PyObject * obj2 = 0 ;
45250 char * kwnames[] = {
45251 (char *) "self",(char *) "x",(char *) "y", NULL
45252 };
45253
45254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45256 if (!SWIG_IsOK(res1)) {
45257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45258 }
45259 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45260 ecode2 = SWIG_AsVal_int(obj1, &val2);
45261 if (!SWIG_IsOK(ecode2)) {
45262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45263 }
45264 arg2 = static_cast< int >(val2);
45265 ecode3 = SWIG_AsVal_int(obj2, &val3);
45266 if (!SWIG_IsOK(ecode3)) {
45267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45268 }
45269 arg3 = static_cast< int >(val3);
45270 {
45271 PyThreadState* __tstate = wxPyBeginAllowThreads();
45272 (arg1)->SetInitSize(arg2,arg3);
45273 wxPyEndAllowThreads(__tstate);
45274 if (PyErr_Occurred()) SWIG_fail;
45275 }
45276 resultobj = SWIG_Py_Void();
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45284 PyObject *resultobj = 0;
45285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45286 int arg2 ;
45287 int arg3 ;
45288 void *argp1 = 0 ;
45289 int res1 = 0 ;
45290 int val2 ;
45291 int ecode2 = 0 ;
45292 int val3 ;
45293 int ecode3 = 0 ;
45294 PyObject * obj0 = 0 ;
45295 PyObject * obj1 = 0 ;
45296 PyObject * obj2 = 0 ;
45297 char * kwnames[] = {
45298 (char *) "self",(char *) "width",(char *) "height", NULL
45299 };
45300
45301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45303 if (!SWIG_IsOK(res1)) {
45304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45305 }
45306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45307 ecode2 = SWIG_AsVal_int(obj1, &val2);
45308 if (!SWIG_IsOK(ecode2)) {
45309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45310 }
45311 arg2 = static_cast< int >(val2);
45312 ecode3 = SWIG_AsVal_int(obj2, &val3);
45313 if (!SWIG_IsOK(ecode3)) {
45314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45315 }
45316 arg3 = static_cast< int >(val3);
45317 {
45318 PyThreadState* __tstate = wxPyBeginAllowThreads();
45319 (arg1)->SetRatio(arg2,arg3);
45320 wxPyEndAllowThreads(__tstate);
45321 if (PyErr_Occurred()) SWIG_fail;
45322 }
45323 resultobj = SWIG_Py_Void();
45324 return resultobj;
45325 fail:
45326 return NULL;
45327 }
45328
45329
45330 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45331 PyObject *resultobj = 0;
45332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45333 wxSize *arg2 = 0 ;
45334 void *argp1 = 0 ;
45335 int res1 = 0 ;
45336 wxSize temp2 ;
45337 PyObject * obj0 = 0 ;
45338 PyObject * obj1 = 0 ;
45339 char * kwnames[] = {
45340 (char *) "self",(char *) "size", NULL
45341 };
45342
45343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45345 if (!SWIG_IsOK(res1)) {
45346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45347 }
45348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45349 {
45350 arg2 = &temp2;
45351 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45352 }
45353 {
45354 PyThreadState* __tstate = wxPyBeginAllowThreads();
45355 (arg1)->SetRatio((wxSize const &)*arg2);
45356 wxPyEndAllowThreads(__tstate);
45357 if (PyErr_Occurred()) SWIG_fail;
45358 }
45359 resultobj = SWIG_Py_Void();
45360 return resultobj;
45361 fail:
45362 return NULL;
45363 }
45364
45365
45366 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45367 PyObject *resultobj = 0;
45368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45369 float arg2 ;
45370 void *argp1 = 0 ;
45371 int res1 = 0 ;
45372 float val2 ;
45373 int ecode2 = 0 ;
45374 PyObject * obj0 = 0 ;
45375 PyObject * obj1 = 0 ;
45376 char * kwnames[] = {
45377 (char *) "self",(char *) "ratio", NULL
45378 };
45379
45380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45382 if (!SWIG_IsOK(res1)) {
45383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45384 }
45385 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45386 ecode2 = SWIG_AsVal_float(obj1, &val2);
45387 if (!SWIG_IsOK(ecode2)) {
45388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45389 }
45390 arg2 = static_cast< float >(val2);
45391 {
45392 PyThreadState* __tstate = wxPyBeginAllowThreads();
45393 (arg1)->SetRatio(arg2);
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 resultobj = SWIG_Py_Void();
45398 return resultobj;
45399 fail:
45400 return NULL;
45401 }
45402
45403
45404 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45405 PyObject *resultobj = 0;
45406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45407 float result;
45408 void *argp1 = 0 ;
45409 int res1 = 0 ;
45410 PyObject *swig_obj[1] ;
45411
45412 if (!args) SWIG_fail;
45413 swig_obj[0] = args;
45414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45415 if (!SWIG_IsOK(res1)) {
45416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45417 }
45418 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45419 {
45420 PyThreadState* __tstate = wxPyBeginAllowThreads();
45421 result = (float)(arg1)->GetRatio();
45422 wxPyEndAllowThreads(__tstate);
45423 if (PyErr_Occurred()) SWIG_fail;
45424 }
45425 resultobj = SWIG_From_float(static_cast< float >(result));
45426 return resultobj;
45427 fail:
45428 return NULL;
45429 }
45430
45431
45432 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45433 PyObject *resultobj = 0;
45434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45435 wxRect result;
45436 void *argp1 = 0 ;
45437 int res1 = 0 ;
45438 PyObject *swig_obj[1] ;
45439
45440 if (!args) SWIG_fail;
45441 swig_obj[0] = args;
45442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45443 if (!SWIG_IsOK(res1)) {
45444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45445 }
45446 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45447 {
45448 PyThreadState* __tstate = wxPyBeginAllowThreads();
45449 result = (arg1)->GetRect();
45450 wxPyEndAllowThreads(__tstate);
45451 if (PyErr_Occurred()) SWIG_fail;
45452 }
45453 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45461 PyObject *resultobj = 0;
45462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45463 bool result;
45464 void *argp1 = 0 ;
45465 int res1 = 0 ;
45466 PyObject *swig_obj[1] ;
45467
45468 if (!args) SWIG_fail;
45469 swig_obj[0] = args;
45470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45471 if (!SWIG_IsOK(res1)) {
45472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45473 }
45474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45475 {
45476 PyThreadState* __tstate = wxPyBeginAllowThreads();
45477 result = (bool)(arg1)->IsWindow();
45478 wxPyEndAllowThreads(__tstate);
45479 if (PyErr_Occurred()) SWIG_fail;
45480 }
45481 {
45482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45483 }
45484 return resultobj;
45485 fail:
45486 return NULL;
45487 }
45488
45489
45490 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45491 PyObject *resultobj = 0;
45492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45493 bool result;
45494 void *argp1 = 0 ;
45495 int res1 = 0 ;
45496 PyObject *swig_obj[1] ;
45497
45498 if (!args) SWIG_fail;
45499 swig_obj[0] = args;
45500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45501 if (!SWIG_IsOK(res1)) {
45502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45503 }
45504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45505 {
45506 PyThreadState* __tstate = wxPyBeginAllowThreads();
45507 result = (bool)(arg1)->IsSizer();
45508 wxPyEndAllowThreads(__tstate);
45509 if (PyErr_Occurred()) SWIG_fail;
45510 }
45511 {
45512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45513 }
45514 return resultobj;
45515 fail:
45516 return NULL;
45517 }
45518
45519
45520 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45521 PyObject *resultobj = 0;
45522 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45523 bool result;
45524 void *argp1 = 0 ;
45525 int res1 = 0 ;
45526 PyObject *swig_obj[1] ;
45527
45528 if (!args) SWIG_fail;
45529 swig_obj[0] = args;
45530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45531 if (!SWIG_IsOK(res1)) {
45532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45533 }
45534 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45535 {
45536 PyThreadState* __tstate = wxPyBeginAllowThreads();
45537 result = (bool)(arg1)->IsSpacer();
45538 wxPyEndAllowThreads(__tstate);
45539 if (PyErr_Occurred()) SWIG_fail;
45540 }
45541 {
45542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45543 }
45544 return resultobj;
45545 fail:
45546 return NULL;
45547 }
45548
45549
45550 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45551 PyObject *resultobj = 0;
45552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45553 int arg2 ;
45554 void *argp1 = 0 ;
45555 int res1 = 0 ;
45556 int val2 ;
45557 int ecode2 = 0 ;
45558 PyObject * obj0 = 0 ;
45559 PyObject * obj1 = 0 ;
45560 char * kwnames[] = {
45561 (char *) "self",(char *) "proportion", NULL
45562 };
45563
45564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45566 if (!SWIG_IsOK(res1)) {
45567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45568 }
45569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45570 ecode2 = SWIG_AsVal_int(obj1, &val2);
45571 if (!SWIG_IsOK(ecode2)) {
45572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45573 }
45574 arg2 = static_cast< int >(val2);
45575 {
45576 PyThreadState* __tstate = wxPyBeginAllowThreads();
45577 (arg1)->SetProportion(arg2);
45578 wxPyEndAllowThreads(__tstate);
45579 if (PyErr_Occurred()) SWIG_fail;
45580 }
45581 resultobj = SWIG_Py_Void();
45582 return resultobj;
45583 fail:
45584 return NULL;
45585 }
45586
45587
45588 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45589 PyObject *resultobj = 0;
45590 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45591 int result;
45592 void *argp1 = 0 ;
45593 int res1 = 0 ;
45594 PyObject *swig_obj[1] ;
45595
45596 if (!args) SWIG_fail;
45597 swig_obj[0] = args;
45598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45599 if (!SWIG_IsOK(res1)) {
45600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45601 }
45602 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45603 {
45604 PyThreadState* __tstate = wxPyBeginAllowThreads();
45605 result = (int)(arg1)->GetProportion();
45606 wxPyEndAllowThreads(__tstate);
45607 if (PyErr_Occurred()) SWIG_fail;
45608 }
45609 resultobj = SWIG_From_int(static_cast< int >(result));
45610 return resultobj;
45611 fail:
45612 return NULL;
45613 }
45614
45615
45616 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45617 PyObject *resultobj = 0;
45618 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45619 int arg2 ;
45620 void *argp1 = 0 ;
45621 int res1 = 0 ;
45622 int val2 ;
45623 int ecode2 = 0 ;
45624 PyObject * obj0 = 0 ;
45625 PyObject * obj1 = 0 ;
45626 char * kwnames[] = {
45627 (char *) "self",(char *) "flag", NULL
45628 };
45629
45630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45634 }
45635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45636 ecode2 = SWIG_AsVal_int(obj1, &val2);
45637 if (!SWIG_IsOK(ecode2)) {
45638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45639 }
45640 arg2 = static_cast< int >(val2);
45641 {
45642 PyThreadState* __tstate = wxPyBeginAllowThreads();
45643 (arg1)->SetFlag(arg2);
45644 wxPyEndAllowThreads(__tstate);
45645 if (PyErr_Occurred()) SWIG_fail;
45646 }
45647 resultobj = SWIG_Py_Void();
45648 return resultobj;
45649 fail:
45650 return NULL;
45651 }
45652
45653
45654 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45655 PyObject *resultobj = 0;
45656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45657 int result;
45658 void *argp1 = 0 ;
45659 int res1 = 0 ;
45660 PyObject *swig_obj[1] ;
45661
45662 if (!args) SWIG_fail;
45663 swig_obj[0] = args;
45664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45665 if (!SWIG_IsOK(res1)) {
45666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45667 }
45668 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45669 {
45670 PyThreadState* __tstate = wxPyBeginAllowThreads();
45671 result = (int)(arg1)->GetFlag();
45672 wxPyEndAllowThreads(__tstate);
45673 if (PyErr_Occurred()) SWIG_fail;
45674 }
45675 resultobj = SWIG_From_int(static_cast< int >(result));
45676 return resultobj;
45677 fail:
45678 return NULL;
45679 }
45680
45681
45682 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45683 PyObject *resultobj = 0;
45684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45685 int arg2 ;
45686 void *argp1 = 0 ;
45687 int res1 = 0 ;
45688 int val2 ;
45689 int ecode2 = 0 ;
45690 PyObject * obj0 = 0 ;
45691 PyObject * obj1 = 0 ;
45692 char * kwnames[] = {
45693 (char *) "self",(char *) "border", NULL
45694 };
45695
45696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45700 }
45701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45702 ecode2 = SWIG_AsVal_int(obj1, &val2);
45703 if (!SWIG_IsOK(ecode2)) {
45704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45705 }
45706 arg2 = static_cast< int >(val2);
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 (arg1)->SetBorder(arg2);
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 resultobj = SWIG_Py_Void();
45714 return resultobj;
45715 fail:
45716 return NULL;
45717 }
45718
45719
45720 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45721 PyObject *resultobj = 0;
45722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45723 int result;
45724 void *argp1 = 0 ;
45725 int res1 = 0 ;
45726 PyObject *swig_obj[1] ;
45727
45728 if (!args) SWIG_fail;
45729 swig_obj[0] = args;
45730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45733 }
45734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45735 {
45736 PyThreadState* __tstate = wxPyBeginAllowThreads();
45737 result = (int)(arg1)->GetBorder();
45738 wxPyEndAllowThreads(__tstate);
45739 if (PyErr_Occurred()) SWIG_fail;
45740 }
45741 resultobj = SWIG_From_int(static_cast< int >(result));
45742 return resultobj;
45743 fail:
45744 return NULL;
45745 }
45746
45747
45748 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45749 PyObject *resultobj = 0;
45750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45751 wxWindow *result = 0 ;
45752 void *argp1 = 0 ;
45753 int res1 = 0 ;
45754 PyObject *swig_obj[1] ;
45755
45756 if (!args) SWIG_fail;
45757 swig_obj[0] = args;
45758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45759 if (!SWIG_IsOK(res1)) {
45760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45761 }
45762 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 result = (wxWindow *)(arg1)->GetWindow();
45766 wxPyEndAllowThreads(__tstate);
45767 if (PyErr_Occurred()) SWIG_fail;
45768 }
45769 {
45770 resultobj = wxPyMake_wxObject(result, 0);
45771 }
45772 return resultobj;
45773 fail:
45774 return NULL;
45775 }
45776
45777
45778 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45779 PyObject *resultobj = 0;
45780 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45781 wxWindow *arg2 = (wxWindow *) 0 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 void *argp2 = 0 ;
45785 int res2 = 0 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "window", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45796 }
45797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45799 if (!SWIG_IsOK(res2)) {
45800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45801 }
45802 arg2 = reinterpret_cast< wxWindow * >(argp2);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 (arg1)->SetWindow(arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = SWIG_Py_Void();
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45817 PyObject *resultobj = 0;
45818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45819 wxSizer *result = 0 ;
45820 void *argp1 = 0 ;
45821 int res1 = 0 ;
45822 PyObject *swig_obj[1] ;
45823
45824 if (!args) SWIG_fail;
45825 swig_obj[0] = args;
45826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45827 if (!SWIG_IsOK(res1)) {
45828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45829 }
45830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45831 {
45832 PyThreadState* __tstate = wxPyBeginAllowThreads();
45833 result = (wxSizer *)(arg1)->GetSizer();
45834 wxPyEndAllowThreads(__tstate);
45835 if (PyErr_Occurred()) SWIG_fail;
45836 }
45837 {
45838 resultobj = wxPyMake_wxObject(result, (bool)0);
45839 }
45840 return resultobj;
45841 fail:
45842 return NULL;
45843 }
45844
45845
45846 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45847 PyObject *resultobj = 0;
45848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45849 wxSizer *arg2 = (wxSizer *) 0 ;
45850 void *argp1 = 0 ;
45851 int res1 = 0 ;
45852 int res2 = 0 ;
45853 PyObject * obj0 = 0 ;
45854 PyObject * obj1 = 0 ;
45855 char * kwnames[] = {
45856 (char *) "self",(char *) "sizer", NULL
45857 };
45858
45859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45861 if (!SWIG_IsOK(res1)) {
45862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45863 }
45864 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45865 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45866 if (!SWIG_IsOK(res2)) {
45867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45868 }
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 (arg1)->SetSizer(arg2);
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 resultobj = SWIG_Py_Void();
45876 return resultobj;
45877 fail:
45878 return NULL;
45879 }
45880
45881
45882 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45883 PyObject *resultobj = 0;
45884 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45885 wxSize *result = 0 ;
45886 void *argp1 = 0 ;
45887 int res1 = 0 ;
45888 PyObject *swig_obj[1] ;
45889
45890 if (!args) SWIG_fail;
45891 swig_obj[0] = args;
45892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45893 if (!SWIG_IsOK(res1)) {
45894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45895 }
45896 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45897 {
45898 PyThreadState* __tstate = wxPyBeginAllowThreads();
45899 {
45900 wxSize const &_result_ref = (arg1)->GetSpacer();
45901 result = (wxSize *) &_result_ref;
45902 }
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45907 return resultobj;
45908 fail:
45909 return NULL;
45910 }
45911
45912
45913 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45914 PyObject *resultobj = 0;
45915 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45916 wxSize *arg2 = 0 ;
45917 void *argp1 = 0 ;
45918 int res1 = 0 ;
45919 wxSize temp2 ;
45920 PyObject * obj0 = 0 ;
45921 PyObject * obj1 = 0 ;
45922 char * kwnames[] = {
45923 (char *) "self",(char *) "size", NULL
45924 };
45925
45926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45928 if (!SWIG_IsOK(res1)) {
45929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45930 }
45931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45932 {
45933 arg2 = &temp2;
45934 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45935 }
45936 {
45937 PyThreadState* __tstate = wxPyBeginAllowThreads();
45938 (arg1)->SetSpacer((wxSize const &)*arg2);
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 resultobj = SWIG_Py_Void();
45943 return resultobj;
45944 fail:
45945 return NULL;
45946 }
45947
45948
45949 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45950 PyObject *resultobj = 0;
45951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45952 bool arg2 ;
45953 void *argp1 = 0 ;
45954 int res1 = 0 ;
45955 bool val2 ;
45956 int ecode2 = 0 ;
45957 PyObject * obj0 = 0 ;
45958 PyObject * obj1 = 0 ;
45959 char * kwnames[] = {
45960 (char *) "self",(char *) "show", NULL
45961 };
45962
45963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45967 }
45968 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45970 if (!SWIG_IsOK(ecode2)) {
45971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45972 }
45973 arg2 = static_cast< bool >(val2);
45974 {
45975 PyThreadState* __tstate = wxPyBeginAllowThreads();
45976 (arg1)->Show(arg2);
45977 wxPyEndAllowThreads(__tstate);
45978 if (PyErr_Occurred()) SWIG_fail;
45979 }
45980 resultobj = SWIG_Py_Void();
45981 return resultobj;
45982 fail:
45983 return NULL;
45984 }
45985
45986
45987 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45988 PyObject *resultobj = 0;
45989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45990 bool result;
45991 void *argp1 = 0 ;
45992 int res1 = 0 ;
45993 PyObject *swig_obj[1] ;
45994
45995 if (!args) SWIG_fail;
45996 swig_obj[0] = args;
45997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45998 if (!SWIG_IsOK(res1)) {
45999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46000 }
46001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46002 {
46003 PyThreadState* __tstate = wxPyBeginAllowThreads();
46004 result = (bool)(arg1)->IsShown();
46005 wxPyEndAllowThreads(__tstate);
46006 if (PyErr_Occurred()) SWIG_fail;
46007 }
46008 {
46009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46010 }
46011 return resultobj;
46012 fail:
46013 return NULL;
46014 }
46015
46016
46017 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46018 PyObject *resultobj = 0;
46019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46020 wxPoint result;
46021 void *argp1 = 0 ;
46022 int res1 = 0 ;
46023 PyObject *swig_obj[1] ;
46024
46025 if (!args) SWIG_fail;
46026 swig_obj[0] = args;
46027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46028 if (!SWIG_IsOK(res1)) {
46029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46030 }
46031 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46032 {
46033 PyThreadState* __tstate = wxPyBeginAllowThreads();
46034 result = (arg1)->GetPosition();
46035 wxPyEndAllowThreads(__tstate);
46036 if (PyErr_Occurred()) SWIG_fail;
46037 }
46038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46039 return resultobj;
46040 fail:
46041 return NULL;
46042 }
46043
46044
46045 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46046 PyObject *resultobj = 0;
46047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46048 PyObject *result = 0 ;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 PyObject *swig_obj[1] ;
46052
46053 if (!args) SWIG_fail;
46054 swig_obj[0] = args;
46055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46058 }
46059 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46060 {
46061 PyThreadState* __tstate = wxPyBeginAllowThreads();
46062 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46063 wxPyEndAllowThreads(__tstate);
46064 if (PyErr_Occurred()) SWIG_fail;
46065 }
46066 resultobj = result;
46067 return resultobj;
46068 fail:
46069 return NULL;
46070 }
46071
46072
46073 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46074 PyObject *resultobj = 0;
46075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46076 PyObject *arg2 = (PyObject *) 0 ;
46077 void *argp1 = 0 ;
46078 int res1 = 0 ;
46079 PyObject * obj0 = 0 ;
46080 PyObject * obj1 = 0 ;
46081 char * kwnames[] = {
46082 (char *) "self",(char *) "userData", NULL
46083 };
46084
46085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46087 if (!SWIG_IsOK(res1)) {
46088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46089 }
46090 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46091 arg2 = obj1;
46092 {
46093 PyThreadState* __tstate = wxPyBeginAllowThreads();
46094 wxSizerItem_SetUserData(arg1,arg2);
46095 wxPyEndAllowThreads(__tstate);
46096 if (PyErr_Occurred()) SWIG_fail;
46097 }
46098 resultobj = SWIG_Py_Void();
46099 return resultobj;
46100 fail:
46101 return NULL;
46102 }
46103
46104
46105 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46106 PyObject *obj;
46107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46108 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46109 return SWIG_Py_Void();
46110 }
46111
46112 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46113 return SWIG_Python_InitShadowInstance(args);
46114 }
46115
46116 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46117 PyObject *resultobj = 0;
46118 wxSizer *arg1 = (wxSizer *) 0 ;
46119 void *argp1 = 0 ;
46120 int res1 = 0 ;
46121 PyObject *swig_obj[1] ;
46122
46123 if (!args) SWIG_fail;
46124 swig_obj[0] = args;
46125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46126 if (!SWIG_IsOK(res1)) {
46127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46128 }
46129 arg1 = reinterpret_cast< wxSizer * >(argp1);
46130 {
46131 PyThreadState* __tstate = wxPyBeginAllowThreads();
46132 delete arg1;
46133
46134 wxPyEndAllowThreads(__tstate);
46135 if (PyErr_Occurred()) SWIG_fail;
46136 }
46137 resultobj = SWIG_Py_Void();
46138 return resultobj;
46139 fail:
46140 return NULL;
46141 }
46142
46143
46144 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46145 PyObject *resultobj = 0;
46146 wxSizer *arg1 = (wxSizer *) 0 ;
46147 PyObject *arg2 = (PyObject *) 0 ;
46148 void *argp1 = 0 ;
46149 int res1 = 0 ;
46150 PyObject * obj0 = 0 ;
46151 PyObject * obj1 = 0 ;
46152 char * kwnames[] = {
46153 (char *) "self",(char *) "_self", NULL
46154 };
46155
46156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46160 }
46161 arg1 = reinterpret_cast< wxSizer * >(argp1);
46162 arg2 = obj1;
46163 {
46164 PyThreadState* __tstate = wxPyBeginAllowThreads();
46165 wxSizer__setOORInfo(arg1,arg2);
46166 wxPyEndAllowThreads(__tstate);
46167 if (PyErr_Occurred()) SWIG_fail;
46168 }
46169 resultobj = SWIG_Py_Void();
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxSizer *arg1 = (wxSizer *) 0 ;
46179 PyObject *arg2 = (PyObject *) 0 ;
46180 int arg3 = (int) 0 ;
46181 int arg4 = (int) 0 ;
46182 int arg5 = (int) 0 ;
46183 PyObject *arg6 = (PyObject *) NULL ;
46184 wxSizerItem *result = 0 ;
46185 void *argp1 = 0 ;
46186 int res1 = 0 ;
46187 int val3 ;
46188 int ecode3 = 0 ;
46189 int val4 ;
46190 int ecode4 = 0 ;
46191 int val5 ;
46192 int ecode5 = 0 ;
46193 PyObject * obj0 = 0 ;
46194 PyObject * obj1 = 0 ;
46195 PyObject * obj2 = 0 ;
46196 PyObject * obj3 = 0 ;
46197 PyObject * obj4 = 0 ;
46198 PyObject * obj5 = 0 ;
46199 char * kwnames[] = {
46200 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46201 };
46202
46203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46205 if (!SWIG_IsOK(res1)) {
46206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46207 }
46208 arg1 = reinterpret_cast< wxSizer * >(argp1);
46209 arg2 = obj1;
46210 if (obj2) {
46211 ecode3 = SWIG_AsVal_int(obj2, &val3);
46212 if (!SWIG_IsOK(ecode3)) {
46213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46214 }
46215 arg3 = static_cast< int >(val3);
46216 }
46217 if (obj3) {
46218 ecode4 = SWIG_AsVal_int(obj3, &val4);
46219 if (!SWIG_IsOK(ecode4)) {
46220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46221 }
46222 arg4 = static_cast< int >(val4);
46223 }
46224 if (obj4) {
46225 ecode5 = SWIG_AsVal_int(obj4, &val5);
46226 if (!SWIG_IsOK(ecode5)) {
46227 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46228 }
46229 arg5 = static_cast< int >(val5);
46230 }
46231 if (obj5) {
46232 arg6 = obj5;
46233 }
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46241 return resultobj;
46242 fail:
46243 return NULL;
46244 }
46245
46246
46247 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46248 PyObject *resultobj = 0;
46249 wxSizer *arg1 = (wxSizer *) 0 ;
46250 int arg2 ;
46251 PyObject *arg3 = (PyObject *) 0 ;
46252 int arg4 = (int) 0 ;
46253 int arg5 = (int) 0 ;
46254 int arg6 = (int) 0 ;
46255 PyObject *arg7 = (PyObject *) NULL ;
46256 wxSizerItem *result = 0 ;
46257 void *argp1 = 0 ;
46258 int res1 = 0 ;
46259 int val2 ;
46260 int ecode2 = 0 ;
46261 int val4 ;
46262 int ecode4 = 0 ;
46263 int val5 ;
46264 int ecode5 = 0 ;
46265 int val6 ;
46266 int ecode6 = 0 ;
46267 PyObject * obj0 = 0 ;
46268 PyObject * obj1 = 0 ;
46269 PyObject * obj2 = 0 ;
46270 PyObject * obj3 = 0 ;
46271 PyObject * obj4 = 0 ;
46272 PyObject * obj5 = 0 ;
46273 PyObject * obj6 = 0 ;
46274 char * kwnames[] = {
46275 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46276 };
46277
46278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46280 if (!SWIG_IsOK(res1)) {
46281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46282 }
46283 arg1 = reinterpret_cast< wxSizer * >(argp1);
46284 ecode2 = SWIG_AsVal_int(obj1, &val2);
46285 if (!SWIG_IsOK(ecode2)) {
46286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46287 }
46288 arg2 = static_cast< int >(val2);
46289 arg3 = obj2;
46290 if (obj3) {
46291 ecode4 = SWIG_AsVal_int(obj3, &val4);
46292 if (!SWIG_IsOK(ecode4)) {
46293 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46294 }
46295 arg4 = static_cast< int >(val4);
46296 }
46297 if (obj4) {
46298 ecode5 = SWIG_AsVal_int(obj4, &val5);
46299 if (!SWIG_IsOK(ecode5)) {
46300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46301 }
46302 arg5 = static_cast< int >(val5);
46303 }
46304 if (obj5) {
46305 ecode6 = SWIG_AsVal_int(obj5, &val6);
46306 if (!SWIG_IsOK(ecode6)) {
46307 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46308 }
46309 arg6 = static_cast< int >(val6);
46310 }
46311 if (obj6) {
46312 arg7 = obj6;
46313 }
46314 {
46315 PyThreadState* __tstate = wxPyBeginAllowThreads();
46316 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46317 wxPyEndAllowThreads(__tstate);
46318 if (PyErr_Occurred()) SWIG_fail;
46319 }
46320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46321 return resultobj;
46322 fail:
46323 return NULL;
46324 }
46325
46326
46327 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46328 PyObject *resultobj = 0;
46329 wxSizer *arg1 = (wxSizer *) 0 ;
46330 PyObject *arg2 = (PyObject *) 0 ;
46331 int arg3 = (int) 0 ;
46332 int arg4 = (int) 0 ;
46333 int arg5 = (int) 0 ;
46334 PyObject *arg6 = (PyObject *) NULL ;
46335 wxSizerItem *result = 0 ;
46336 void *argp1 = 0 ;
46337 int res1 = 0 ;
46338 int val3 ;
46339 int ecode3 = 0 ;
46340 int val4 ;
46341 int ecode4 = 0 ;
46342 int val5 ;
46343 int ecode5 = 0 ;
46344 PyObject * obj0 = 0 ;
46345 PyObject * obj1 = 0 ;
46346 PyObject * obj2 = 0 ;
46347 PyObject * obj3 = 0 ;
46348 PyObject * obj4 = 0 ;
46349 PyObject * obj5 = 0 ;
46350 char * kwnames[] = {
46351 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46352 };
46353
46354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46356 if (!SWIG_IsOK(res1)) {
46357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46358 }
46359 arg1 = reinterpret_cast< wxSizer * >(argp1);
46360 arg2 = obj1;
46361 if (obj2) {
46362 ecode3 = SWIG_AsVal_int(obj2, &val3);
46363 if (!SWIG_IsOK(ecode3)) {
46364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46365 }
46366 arg3 = static_cast< int >(val3);
46367 }
46368 if (obj3) {
46369 ecode4 = SWIG_AsVal_int(obj3, &val4);
46370 if (!SWIG_IsOK(ecode4)) {
46371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46372 }
46373 arg4 = static_cast< int >(val4);
46374 }
46375 if (obj4) {
46376 ecode5 = SWIG_AsVal_int(obj4, &val5);
46377 if (!SWIG_IsOK(ecode5)) {
46378 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46379 }
46380 arg5 = static_cast< int >(val5);
46381 }
46382 if (obj5) {
46383 arg6 = obj5;
46384 }
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46399 PyObject *resultobj = 0;
46400 wxSizer *arg1 = (wxSizer *) 0 ;
46401 PyObject *arg2 = (PyObject *) 0 ;
46402 bool result;
46403 void *argp1 = 0 ;
46404 int res1 = 0 ;
46405 PyObject * obj0 = 0 ;
46406 PyObject * obj1 = 0 ;
46407 char * kwnames[] = {
46408 (char *) "self",(char *) "item", NULL
46409 };
46410
46411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46413 if (!SWIG_IsOK(res1)) {
46414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46415 }
46416 arg1 = reinterpret_cast< wxSizer * >(argp1);
46417 arg2 = obj1;
46418 {
46419 PyThreadState* __tstate = wxPyBeginAllowThreads();
46420 result = (bool)wxSizer_Remove(arg1,arg2);
46421 wxPyEndAllowThreads(__tstate);
46422 if (PyErr_Occurred()) SWIG_fail;
46423 }
46424 {
46425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46426 }
46427 return resultobj;
46428 fail:
46429 return NULL;
46430 }
46431
46432
46433 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46434 PyObject *resultobj = 0;
46435 wxSizer *arg1 = (wxSizer *) 0 ;
46436 PyObject *arg2 = (PyObject *) 0 ;
46437 bool result;
46438 void *argp1 = 0 ;
46439 int res1 = 0 ;
46440 PyObject * obj0 = 0 ;
46441 PyObject * obj1 = 0 ;
46442 char * kwnames[] = {
46443 (char *) "self",(char *) "item", NULL
46444 };
46445
46446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46448 if (!SWIG_IsOK(res1)) {
46449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46450 }
46451 arg1 = reinterpret_cast< wxSizer * >(argp1);
46452 arg2 = obj1;
46453 {
46454 PyThreadState* __tstate = wxPyBeginAllowThreads();
46455 result = (bool)wxSizer_Detach(arg1,arg2);
46456 wxPyEndAllowThreads(__tstate);
46457 if (PyErr_Occurred()) SWIG_fail;
46458 }
46459 {
46460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46461 }
46462 return resultobj;
46463 fail:
46464 return NULL;
46465 }
46466
46467
46468 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46469 PyObject *resultobj = 0;
46470 wxSizer *arg1 = (wxSizer *) 0 ;
46471 PyObject *arg2 = (PyObject *) 0 ;
46472 wxSizerItem *result = 0 ;
46473 void *argp1 = 0 ;
46474 int res1 = 0 ;
46475 PyObject * obj0 = 0 ;
46476 PyObject * obj1 = 0 ;
46477 char * kwnames[] = {
46478 (char *) "self",(char *) "item", NULL
46479 };
46480
46481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46485 }
46486 arg1 = reinterpret_cast< wxSizer * >(argp1);
46487 arg2 = obj1;
46488 {
46489 PyThreadState* __tstate = wxPyBeginAllowThreads();
46490 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46491 wxPyEndAllowThreads(__tstate);
46492 if (PyErr_Occurred()) SWIG_fail;
46493 }
46494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46495 return resultobj;
46496 fail:
46497 return NULL;
46498 }
46499
46500
46501 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46502 PyObject *resultobj = 0;
46503 wxSizer *arg1 = (wxSizer *) 0 ;
46504 PyObject *arg2 = (PyObject *) 0 ;
46505 wxSize *arg3 = 0 ;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 wxSize temp3 ;
46509 PyObject * obj0 = 0 ;
46510 PyObject * obj1 = 0 ;
46511 PyObject * obj2 = 0 ;
46512 char * kwnames[] = {
46513 (char *) "self",(char *) "item",(char *) "size", NULL
46514 };
46515
46516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizer * >(argp1);
46522 arg2 = obj1;
46523 {
46524 arg3 = &temp3;
46525 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46526 }
46527 {
46528 PyThreadState* __tstate = wxPyBeginAllowThreads();
46529 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46530 wxPyEndAllowThreads(__tstate);
46531 if (PyErr_Occurred()) SWIG_fail;
46532 }
46533 resultobj = SWIG_Py_Void();
46534 return resultobj;
46535 fail:
46536 return NULL;
46537 }
46538
46539
46540 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46541 PyObject *resultobj = 0;
46542 wxSizer *arg1 = (wxSizer *) 0 ;
46543 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46544 wxSizerItem *result = 0 ;
46545 void *argp1 = 0 ;
46546 int res1 = 0 ;
46547 int res2 = 0 ;
46548 PyObject * obj0 = 0 ;
46549 PyObject * obj1 = 0 ;
46550 char * kwnames[] = {
46551 (char *) "self",(char *) "item", NULL
46552 };
46553
46554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46556 if (!SWIG_IsOK(res1)) {
46557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46558 }
46559 arg1 = reinterpret_cast< wxSizer * >(argp1);
46560 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46561 if (!SWIG_IsOK(res2)) {
46562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46563 }
46564 {
46565 PyThreadState* __tstate = wxPyBeginAllowThreads();
46566 result = (wxSizerItem *)(arg1)->Add(arg2);
46567 wxPyEndAllowThreads(__tstate);
46568 if (PyErr_Occurred()) SWIG_fail;
46569 }
46570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46578 PyObject *resultobj = 0;
46579 wxSizer *arg1 = (wxSizer *) 0 ;
46580 size_t arg2 ;
46581 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46582 wxSizerItem *result = 0 ;
46583 void *argp1 = 0 ;
46584 int res1 = 0 ;
46585 size_t val2 ;
46586 int ecode2 = 0 ;
46587 int res3 = 0 ;
46588 PyObject * obj0 = 0 ;
46589 PyObject * obj1 = 0 ;
46590 PyObject * obj2 = 0 ;
46591 char * kwnames[] = {
46592 (char *) "self",(char *) "index",(char *) "item", NULL
46593 };
46594
46595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46597 if (!SWIG_IsOK(res1)) {
46598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46599 }
46600 arg1 = reinterpret_cast< wxSizer * >(argp1);
46601 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46602 if (!SWIG_IsOK(ecode2)) {
46603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46604 }
46605 arg2 = static_cast< size_t >(val2);
46606 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46607 if (!SWIG_IsOK(res3)) {
46608 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46609 }
46610 {
46611 PyThreadState* __tstate = wxPyBeginAllowThreads();
46612 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46613 wxPyEndAllowThreads(__tstate);
46614 if (PyErr_Occurred()) SWIG_fail;
46615 }
46616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46617 return resultobj;
46618 fail:
46619 return NULL;
46620 }
46621
46622
46623 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46624 PyObject *resultobj = 0;
46625 wxSizer *arg1 = (wxSizer *) 0 ;
46626 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46627 wxSizerItem *result = 0 ;
46628 void *argp1 = 0 ;
46629 int res1 = 0 ;
46630 int res2 = 0 ;
46631 PyObject * obj0 = 0 ;
46632 PyObject * obj1 = 0 ;
46633 char * kwnames[] = {
46634 (char *) "self",(char *) "item", NULL
46635 };
46636
46637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46639 if (!SWIG_IsOK(res1)) {
46640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46641 }
46642 arg1 = reinterpret_cast< wxSizer * >(argp1);
46643 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46644 if (!SWIG_IsOK(res2)) {
46645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46646 }
46647 {
46648 PyThreadState* __tstate = wxPyBeginAllowThreads();
46649 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46650 wxPyEndAllowThreads(__tstate);
46651 if (PyErr_Occurred()) SWIG_fail;
46652 }
46653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46654 return resultobj;
46655 fail:
46656 return NULL;
46657 }
46658
46659
46660 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46661 PyObject *resultobj = 0;
46662 wxSizer *arg1 = (wxSizer *) 0 ;
46663 int arg2 ;
46664 int arg3 ;
46665 int arg4 ;
46666 int arg5 ;
46667 void *argp1 = 0 ;
46668 int res1 = 0 ;
46669 int val2 ;
46670 int ecode2 = 0 ;
46671 int val3 ;
46672 int ecode3 = 0 ;
46673 int val4 ;
46674 int ecode4 = 0 ;
46675 int val5 ;
46676 int ecode5 = 0 ;
46677 PyObject * obj0 = 0 ;
46678 PyObject * obj1 = 0 ;
46679 PyObject * obj2 = 0 ;
46680 PyObject * obj3 = 0 ;
46681 PyObject * obj4 = 0 ;
46682 char * kwnames[] = {
46683 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46684 };
46685
46686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46688 if (!SWIG_IsOK(res1)) {
46689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46690 }
46691 arg1 = reinterpret_cast< wxSizer * >(argp1);
46692 ecode2 = SWIG_AsVal_int(obj1, &val2);
46693 if (!SWIG_IsOK(ecode2)) {
46694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46695 }
46696 arg2 = static_cast< int >(val2);
46697 ecode3 = SWIG_AsVal_int(obj2, &val3);
46698 if (!SWIG_IsOK(ecode3)) {
46699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46700 }
46701 arg3 = static_cast< int >(val3);
46702 ecode4 = SWIG_AsVal_int(obj3, &val4);
46703 if (!SWIG_IsOK(ecode4)) {
46704 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46705 }
46706 arg4 = static_cast< int >(val4);
46707 ecode5 = SWIG_AsVal_int(obj4, &val5);
46708 if (!SWIG_IsOK(ecode5)) {
46709 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46710 }
46711 arg5 = static_cast< int >(val5);
46712 {
46713 PyThreadState* __tstate = wxPyBeginAllowThreads();
46714 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46715 wxPyEndAllowThreads(__tstate);
46716 if (PyErr_Occurred()) SWIG_fail;
46717 }
46718 resultobj = SWIG_Py_Void();
46719 return resultobj;
46720 fail:
46721 return NULL;
46722 }
46723
46724
46725 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46726 PyObject *resultobj = 0;
46727 wxSizer *arg1 = (wxSizer *) 0 ;
46728 wxSize *arg2 = 0 ;
46729 void *argp1 = 0 ;
46730 int res1 = 0 ;
46731 wxSize temp2 ;
46732 PyObject * obj0 = 0 ;
46733 PyObject * obj1 = 0 ;
46734 char * kwnames[] = {
46735 (char *) "self",(char *) "size", NULL
46736 };
46737
46738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46740 if (!SWIG_IsOK(res1)) {
46741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46742 }
46743 arg1 = reinterpret_cast< wxSizer * >(argp1);
46744 {
46745 arg2 = &temp2;
46746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46747 }
46748 {
46749 PyThreadState* __tstate = wxPyBeginAllowThreads();
46750 (arg1)->SetMinSize((wxSize const &)*arg2);
46751 wxPyEndAllowThreads(__tstate);
46752 if (PyErr_Occurred()) SWIG_fail;
46753 }
46754 resultobj = SWIG_Py_Void();
46755 return resultobj;
46756 fail:
46757 return NULL;
46758 }
46759
46760
46761 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46762 PyObject *resultobj = 0;
46763 wxSizer *arg1 = (wxSizer *) 0 ;
46764 wxSize result;
46765 void *argp1 = 0 ;
46766 int res1 = 0 ;
46767 PyObject *swig_obj[1] ;
46768
46769 if (!args) SWIG_fail;
46770 swig_obj[0] = args;
46771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46772 if (!SWIG_IsOK(res1)) {
46773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46774 }
46775 arg1 = reinterpret_cast< wxSizer * >(argp1);
46776 {
46777 PyThreadState* __tstate = wxPyBeginAllowThreads();
46778 result = (arg1)->GetSize();
46779 wxPyEndAllowThreads(__tstate);
46780 if (PyErr_Occurred()) SWIG_fail;
46781 }
46782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46783 return resultobj;
46784 fail:
46785 return NULL;
46786 }
46787
46788
46789 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46790 PyObject *resultobj = 0;
46791 wxSizer *arg1 = (wxSizer *) 0 ;
46792 wxPoint result;
46793 void *argp1 = 0 ;
46794 int res1 = 0 ;
46795 PyObject *swig_obj[1] ;
46796
46797 if (!args) SWIG_fail;
46798 swig_obj[0] = args;
46799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46800 if (!SWIG_IsOK(res1)) {
46801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46802 }
46803 arg1 = reinterpret_cast< wxSizer * >(argp1);
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 result = (arg1)->GetPosition();
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46818 PyObject *resultobj = 0;
46819 wxSizer *arg1 = (wxSizer *) 0 ;
46820 wxSize result;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 PyObject *swig_obj[1] ;
46824
46825 if (!args) SWIG_fail;
46826 swig_obj[0] = args;
46827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46828 if (!SWIG_IsOK(res1)) {
46829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46830 }
46831 arg1 = reinterpret_cast< wxSizer * >(argp1);
46832 {
46833 PyThreadState* __tstate = wxPyBeginAllowThreads();
46834 result = (arg1)->GetMinSize();
46835 wxPyEndAllowThreads(__tstate);
46836 if (PyErr_Occurred()) SWIG_fail;
46837 }
46838 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46839 return resultobj;
46840 fail:
46841 return NULL;
46842 }
46843
46844
46845 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46846 PyObject *resultobj = 0;
46847 wxSizer *arg1 = (wxSizer *) 0 ;
46848 void *argp1 = 0 ;
46849 int res1 = 0 ;
46850 PyObject *swig_obj[1] ;
46851
46852 if (!args) SWIG_fail;
46853 swig_obj[0] = args;
46854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46855 if (!SWIG_IsOK(res1)) {
46856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46857 }
46858 arg1 = reinterpret_cast< wxSizer * >(argp1);
46859 {
46860 PyThreadState* __tstate = wxPyBeginAllowThreads();
46861 (arg1)->RecalcSizes();
46862 wxPyEndAllowThreads(__tstate);
46863 if (PyErr_Occurred()) SWIG_fail;
46864 }
46865 resultobj = SWIG_Py_Void();
46866 return resultobj;
46867 fail:
46868 return NULL;
46869 }
46870
46871
46872 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46873 PyObject *resultobj = 0;
46874 wxSizer *arg1 = (wxSizer *) 0 ;
46875 wxSize result;
46876 void *argp1 = 0 ;
46877 int res1 = 0 ;
46878 PyObject *swig_obj[1] ;
46879
46880 if (!args) SWIG_fail;
46881 swig_obj[0] = args;
46882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46885 }
46886 arg1 = reinterpret_cast< wxSizer * >(argp1);
46887 {
46888 PyThreadState* __tstate = wxPyBeginAllowThreads();
46889 result = (arg1)->CalcMin();
46890 wxPyEndAllowThreads(__tstate);
46891 if (PyErr_Occurred()) SWIG_fail;
46892 }
46893 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46894 return resultobj;
46895 fail:
46896 return NULL;
46897 }
46898
46899
46900 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46901 PyObject *resultobj = 0;
46902 wxSizer *arg1 = (wxSizer *) 0 ;
46903 void *argp1 = 0 ;
46904 int res1 = 0 ;
46905 PyObject *swig_obj[1] ;
46906
46907 if (!args) SWIG_fail;
46908 swig_obj[0] = args;
46909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46910 if (!SWIG_IsOK(res1)) {
46911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46912 }
46913 arg1 = reinterpret_cast< wxSizer * >(argp1);
46914 {
46915 PyThreadState* __tstate = wxPyBeginAllowThreads();
46916 (arg1)->Layout();
46917 wxPyEndAllowThreads(__tstate);
46918 if (PyErr_Occurred()) SWIG_fail;
46919 }
46920 resultobj = SWIG_Py_Void();
46921 return resultobj;
46922 fail:
46923 return NULL;
46924 }
46925
46926
46927 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46928 PyObject *resultobj = 0;
46929 wxSizer *arg1 = (wxSizer *) 0 ;
46930 wxWindow *arg2 = (wxWindow *) 0 ;
46931 wxSize result;
46932 void *argp1 = 0 ;
46933 int res1 = 0 ;
46934 void *argp2 = 0 ;
46935 int res2 = 0 ;
46936 PyObject * obj0 = 0 ;
46937 PyObject * obj1 = 0 ;
46938 char * kwnames[] = {
46939 (char *) "self",(char *) "window", NULL
46940 };
46941
46942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46944 if (!SWIG_IsOK(res1)) {
46945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46946 }
46947 arg1 = reinterpret_cast< wxSizer * >(argp1);
46948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46949 if (!SWIG_IsOK(res2)) {
46950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46951 }
46952 arg2 = reinterpret_cast< wxWindow * >(argp2);
46953 {
46954 PyThreadState* __tstate = wxPyBeginAllowThreads();
46955 result = (arg1)->Fit(arg2);
46956 wxPyEndAllowThreads(__tstate);
46957 if (PyErr_Occurred()) SWIG_fail;
46958 }
46959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46960 return resultobj;
46961 fail:
46962 return NULL;
46963 }
46964
46965
46966 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46967 PyObject *resultobj = 0;
46968 wxSizer *arg1 = (wxSizer *) 0 ;
46969 wxWindow *arg2 = (wxWindow *) 0 ;
46970 void *argp1 = 0 ;
46971 int res1 = 0 ;
46972 void *argp2 = 0 ;
46973 int res2 = 0 ;
46974 PyObject * obj0 = 0 ;
46975 PyObject * obj1 = 0 ;
46976 char * kwnames[] = {
46977 (char *) "self",(char *) "window", NULL
46978 };
46979
46980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46982 if (!SWIG_IsOK(res1)) {
46983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46984 }
46985 arg1 = reinterpret_cast< wxSizer * >(argp1);
46986 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46987 if (!SWIG_IsOK(res2)) {
46988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46989 }
46990 arg2 = reinterpret_cast< wxWindow * >(argp2);
46991 {
46992 PyThreadState* __tstate = wxPyBeginAllowThreads();
46993 (arg1)->FitInside(arg2);
46994 wxPyEndAllowThreads(__tstate);
46995 if (PyErr_Occurred()) SWIG_fail;
46996 }
46997 resultobj = SWIG_Py_Void();
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 wxWindow *arg2 = (wxWindow *) 0 ;
47008 void *argp1 = 0 ;
47009 int res1 = 0 ;
47010 void *argp2 = 0 ;
47011 int res2 = 0 ;
47012 PyObject * obj0 = 0 ;
47013 PyObject * obj1 = 0 ;
47014 char * kwnames[] = {
47015 (char *) "self",(char *) "window", NULL
47016 };
47017
47018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47025 if (!SWIG_IsOK(res2)) {
47026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47027 }
47028 arg2 = reinterpret_cast< wxWindow * >(argp2);
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 (arg1)->SetSizeHints(arg2);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_Py_Void();
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47043 PyObject *resultobj = 0;
47044 wxSizer *arg1 = (wxSizer *) 0 ;
47045 wxWindow *arg2 = (wxWindow *) 0 ;
47046 void *argp1 = 0 ;
47047 int res1 = 0 ;
47048 void *argp2 = 0 ;
47049 int res2 = 0 ;
47050 PyObject * obj0 = 0 ;
47051 PyObject * obj1 = 0 ;
47052 char * kwnames[] = {
47053 (char *) "self",(char *) "window", NULL
47054 };
47055
47056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47058 if (!SWIG_IsOK(res1)) {
47059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47060 }
47061 arg1 = reinterpret_cast< wxSizer * >(argp1);
47062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47063 if (!SWIG_IsOK(res2)) {
47064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47065 }
47066 arg2 = reinterpret_cast< wxWindow * >(argp2);
47067 {
47068 PyThreadState* __tstate = wxPyBeginAllowThreads();
47069 (arg1)->SetVirtualSizeHints(arg2);
47070 wxPyEndAllowThreads(__tstate);
47071 if (PyErr_Occurred()) SWIG_fail;
47072 }
47073 resultobj = SWIG_Py_Void();
47074 return resultobj;
47075 fail:
47076 return NULL;
47077 }
47078
47079
47080 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47081 PyObject *resultobj = 0;
47082 wxSizer *arg1 = (wxSizer *) 0 ;
47083 bool arg2 = (bool) false ;
47084 void *argp1 = 0 ;
47085 int res1 = 0 ;
47086 bool val2 ;
47087 int ecode2 = 0 ;
47088 PyObject * obj0 = 0 ;
47089 PyObject * obj1 = 0 ;
47090 char * kwnames[] = {
47091 (char *) "self",(char *) "deleteWindows", NULL
47092 };
47093
47094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47096 if (!SWIG_IsOK(res1)) {
47097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47098 }
47099 arg1 = reinterpret_cast< wxSizer * >(argp1);
47100 if (obj1) {
47101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47102 if (!SWIG_IsOK(ecode2)) {
47103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47104 }
47105 arg2 = static_cast< bool >(val2);
47106 }
47107 {
47108 PyThreadState* __tstate = wxPyBeginAllowThreads();
47109 (arg1)->Clear(arg2);
47110 wxPyEndAllowThreads(__tstate);
47111 if (PyErr_Occurred()) SWIG_fail;
47112 }
47113 resultobj = SWIG_Py_Void();
47114 return resultobj;
47115 fail:
47116 return NULL;
47117 }
47118
47119
47120 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47121 PyObject *resultobj = 0;
47122 wxSizer *arg1 = (wxSizer *) 0 ;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 PyObject *swig_obj[1] ;
47126
47127 if (!args) SWIG_fail;
47128 swig_obj[0] = args;
47129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47130 if (!SWIG_IsOK(res1)) {
47131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47132 }
47133 arg1 = reinterpret_cast< wxSizer * >(argp1);
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 (arg1)->DeleteWindows();
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 resultobj = SWIG_Py_Void();
47141 return resultobj;
47142 fail:
47143 return NULL;
47144 }
47145
47146
47147 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47148 PyObject *resultobj = 0;
47149 wxSizer *arg1 = (wxSizer *) 0 ;
47150 PyObject *result = 0 ;
47151 void *argp1 = 0 ;
47152 int res1 = 0 ;
47153 PyObject *swig_obj[1] ;
47154
47155 if (!args) SWIG_fail;
47156 swig_obj[0] = args;
47157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47158 if (!SWIG_IsOK(res1)) {
47159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47160 }
47161 arg1 = reinterpret_cast< wxSizer * >(argp1);
47162 {
47163 PyThreadState* __tstate = wxPyBeginAllowThreads();
47164 result = (PyObject *)wxSizer_GetChildren(arg1);
47165 wxPyEndAllowThreads(__tstate);
47166 if (PyErr_Occurred()) SWIG_fail;
47167 }
47168 resultobj = result;
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxSizer *arg1 = (wxSizer *) 0 ;
47178 PyObject *arg2 = (PyObject *) 0 ;
47179 bool arg3 = (bool) true ;
47180 bool arg4 = (bool) false ;
47181 bool result;
47182 void *argp1 = 0 ;
47183 int res1 = 0 ;
47184 bool val3 ;
47185 int ecode3 = 0 ;
47186 bool val4 ;
47187 int ecode4 = 0 ;
47188 PyObject * obj0 = 0 ;
47189 PyObject * obj1 = 0 ;
47190 PyObject * obj2 = 0 ;
47191 PyObject * obj3 = 0 ;
47192 char * kwnames[] = {
47193 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47194 };
47195
47196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47198 if (!SWIG_IsOK(res1)) {
47199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47200 }
47201 arg1 = reinterpret_cast< wxSizer * >(argp1);
47202 arg2 = obj1;
47203 if (obj2) {
47204 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47205 if (!SWIG_IsOK(ecode3)) {
47206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47207 }
47208 arg3 = static_cast< bool >(val3);
47209 }
47210 if (obj3) {
47211 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47212 if (!SWIG_IsOK(ecode4)) {
47213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47214 }
47215 arg4 = static_cast< bool >(val4);
47216 }
47217 {
47218 PyThreadState* __tstate = wxPyBeginAllowThreads();
47219 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47220 wxPyEndAllowThreads(__tstate);
47221 if (PyErr_Occurred()) SWIG_fail;
47222 }
47223 {
47224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47225 }
47226 return resultobj;
47227 fail:
47228 return NULL;
47229 }
47230
47231
47232 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47233 PyObject *resultobj = 0;
47234 wxSizer *arg1 = (wxSizer *) 0 ;
47235 PyObject *arg2 = (PyObject *) 0 ;
47236 bool result;
47237 void *argp1 = 0 ;
47238 int res1 = 0 ;
47239 PyObject * obj0 = 0 ;
47240 PyObject * obj1 = 0 ;
47241 char * kwnames[] = {
47242 (char *) "self",(char *) "item", NULL
47243 };
47244
47245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47247 if (!SWIG_IsOK(res1)) {
47248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47249 }
47250 arg1 = reinterpret_cast< wxSizer * >(argp1);
47251 arg2 = obj1;
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 result = (bool)wxSizer_IsShown(arg1,arg2);
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 {
47259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47260 }
47261 return resultobj;
47262 fail:
47263 return NULL;
47264 }
47265
47266
47267 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47268 PyObject *resultobj = 0;
47269 wxSizer *arg1 = (wxSizer *) 0 ;
47270 bool arg2 ;
47271 void *argp1 = 0 ;
47272 int res1 = 0 ;
47273 bool val2 ;
47274 int ecode2 = 0 ;
47275 PyObject * obj0 = 0 ;
47276 PyObject * obj1 = 0 ;
47277 char * kwnames[] = {
47278 (char *) "self",(char *) "show", NULL
47279 };
47280
47281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47283 if (!SWIG_IsOK(res1)) {
47284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47285 }
47286 arg1 = reinterpret_cast< wxSizer * >(argp1);
47287 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47288 if (!SWIG_IsOK(ecode2)) {
47289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47290 }
47291 arg2 = static_cast< bool >(val2);
47292 {
47293 PyThreadState* __tstate = wxPyBeginAllowThreads();
47294 (arg1)->ShowItems(arg2);
47295 wxPyEndAllowThreads(__tstate);
47296 if (PyErr_Occurred()) SWIG_fail;
47297 }
47298 resultobj = SWIG_Py_Void();
47299 return resultobj;
47300 fail:
47301 return NULL;
47302 }
47303
47304
47305 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47306 PyObject *obj;
47307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47308 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47309 return SWIG_Py_Void();
47310 }
47311
47312 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47313 PyObject *resultobj = 0;
47314 wxPySizer *result = 0 ;
47315
47316 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47317 {
47318 PyThreadState* __tstate = wxPyBeginAllowThreads();
47319 result = (wxPySizer *)new wxPySizer();
47320 wxPyEndAllowThreads(__tstate);
47321 if (PyErr_Occurred()) SWIG_fail;
47322 }
47323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47324 return resultobj;
47325 fail:
47326 return NULL;
47327 }
47328
47329
47330 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47331 PyObject *resultobj = 0;
47332 wxPySizer *arg1 = (wxPySizer *) 0 ;
47333 PyObject *arg2 = (PyObject *) 0 ;
47334 PyObject *arg3 = (PyObject *) 0 ;
47335 void *argp1 = 0 ;
47336 int res1 = 0 ;
47337 PyObject * obj0 = 0 ;
47338 PyObject * obj1 = 0 ;
47339 PyObject * obj2 = 0 ;
47340 char * kwnames[] = {
47341 (char *) "self",(char *) "self",(char *) "_class", NULL
47342 };
47343
47344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47346 if (!SWIG_IsOK(res1)) {
47347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47348 }
47349 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47350 arg2 = obj1;
47351 arg3 = obj2;
47352 {
47353 PyThreadState* __tstate = wxPyBeginAllowThreads();
47354 (arg1)->_setCallbackInfo(arg2,arg3);
47355 wxPyEndAllowThreads(__tstate);
47356 if (PyErr_Occurred()) SWIG_fail;
47357 }
47358 resultobj = SWIG_Py_Void();
47359 return resultobj;
47360 fail:
47361 return NULL;
47362 }
47363
47364
47365 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47366 PyObject *obj;
47367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47368 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47369 return SWIG_Py_Void();
47370 }
47371
47372 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47373 return SWIG_Python_InitShadowInstance(args);
47374 }
47375
47376 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47377 PyObject *resultobj = 0;
47378 int arg1 = (int) wxHORIZONTAL ;
47379 wxBoxSizer *result = 0 ;
47380 int val1 ;
47381 int ecode1 = 0 ;
47382 PyObject * obj0 = 0 ;
47383 char * kwnames[] = {
47384 (char *) "orient", NULL
47385 };
47386
47387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47388 if (obj0) {
47389 ecode1 = SWIG_AsVal_int(obj0, &val1);
47390 if (!SWIG_IsOK(ecode1)) {
47391 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47392 }
47393 arg1 = static_cast< int >(val1);
47394 }
47395 {
47396 PyThreadState* __tstate = wxPyBeginAllowThreads();
47397 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47398 wxPyEndAllowThreads(__tstate);
47399 if (PyErr_Occurred()) SWIG_fail;
47400 }
47401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47402 return resultobj;
47403 fail:
47404 return NULL;
47405 }
47406
47407
47408 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47409 PyObject *resultobj = 0;
47410 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47411 int result;
47412 void *argp1 = 0 ;
47413 int res1 = 0 ;
47414 PyObject *swig_obj[1] ;
47415
47416 if (!args) SWIG_fail;
47417 swig_obj[0] = args;
47418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47419 if (!SWIG_IsOK(res1)) {
47420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47421 }
47422 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47423 {
47424 PyThreadState* __tstate = wxPyBeginAllowThreads();
47425 result = (int)(arg1)->GetOrientation();
47426 wxPyEndAllowThreads(__tstate);
47427 if (PyErr_Occurred()) SWIG_fail;
47428 }
47429 resultobj = SWIG_From_int(static_cast< int >(result));
47430 return resultobj;
47431 fail:
47432 return NULL;
47433 }
47434
47435
47436 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47437 PyObject *resultobj = 0;
47438 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47439 int arg2 ;
47440 void *argp1 = 0 ;
47441 int res1 = 0 ;
47442 int val2 ;
47443 int ecode2 = 0 ;
47444 PyObject * obj0 = 0 ;
47445 PyObject * obj1 = 0 ;
47446 char * kwnames[] = {
47447 (char *) "self",(char *) "orient", NULL
47448 };
47449
47450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47452 if (!SWIG_IsOK(res1)) {
47453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47454 }
47455 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47456 ecode2 = SWIG_AsVal_int(obj1, &val2);
47457 if (!SWIG_IsOK(ecode2)) {
47458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47459 }
47460 arg2 = static_cast< int >(val2);
47461 {
47462 PyThreadState* __tstate = wxPyBeginAllowThreads();
47463 (arg1)->SetOrientation(arg2);
47464 wxPyEndAllowThreads(__tstate);
47465 if (PyErr_Occurred()) SWIG_fail;
47466 }
47467 resultobj = SWIG_Py_Void();
47468 return resultobj;
47469 fail:
47470 return NULL;
47471 }
47472
47473
47474 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47475 PyObject *obj;
47476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47477 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47478 return SWIG_Py_Void();
47479 }
47480
47481 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47482 return SWIG_Python_InitShadowInstance(args);
47483 }
47484
47485 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47486 PyObject *resultobj = 0;
47487 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47488 int arg2 = (int) wxHORIZONTAL ;
47489 wxStaticBoxSizer *result = 0 ;
47490 void *argp1 = 0 ;
47491 int res1 = 0 ;
47492 int val2 ;
47493 int ecode2 = 0 ;
47494 PyObject * obj0 = 0 ;
47495 PyObject * obj1 = 0 ;
47496 char * kwnames[] = {
47497 (char *) "box",(char *) "orient", NULL
47498 };
47499
47500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47502 if (!SWIG_IsOK(res1)) {
47503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47504 }
47505 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47506 if (obj1) {
47507 ecode2 = SWIG_AsVal_int(obj1, &val2);
47508 if (!SWIG_IsOK(ecode2)) {
47509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47510 }
47511 arg2 = static_cast< int >(val2);
47512 }
47513 {
47514 PyThreadState* __tstate = wxPyBeginAllowThreads();
47515 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47516 wxPyEndAllowThreads(__tstate);
47517 if (PyErr_Occurred()) SWIG_fail;
47518 }
47519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47520 return resultobj;
47521 fail:
47522 return NULL;
47523 }
47524
47525
47526 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47527 PyObject *resultobj = 0;
47528 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47529 wxStaticBox *result = 0 ;
47530 void *argp1 = 0 ;
47531 int res1 = 0 ;
47532 PyObject *swig_obj[1] ;
47533
47534 if (!args) SWIG_fail;
47535 swig_obj[0] = args;
47536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47537 if (!SWIG_IsOK(res1)) {
47538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47539 }
47540 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47541 {
47542 PyThreadState* __tstate = wxPyBeginAllowThreads();
47543 result = (wxStaticBox *)(arg1)->GetStaticBox();
47544 wxPyEndAllowThreads(__tstate);
47545 if (PyErr_Occurred()) SWIG_fail;
47546 }
47547 {
47548 resultobj = wxPyMake_wxObject(result, (bool)0);
47549 }
47550 return resultobj;
47551 fail:
47552 return NULL;
47553 }
47554
47555
47556 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47557 PyObject *obj;
47558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47559 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47560 return SWIG_Py_Void();
47561 }
47562
47563 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47564 return SWIG_Python_InitShadowInstance(args);
47565 }
47566
47567 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47568 PyObject *resultobj = 0;
47569 int arg1 = (int) 1 ;
47570 int arg2 = (int) 0 ;
47571 int arg3 = (int) 0 ;
47572 int arg4 = (int) 0 ;
47573 wxGridSizer *result = 0 ;
47574 int val1 ;
47575 int ecode1 = 0 ;
47576 int val2 ;
47577 int ecode2 = 0 ;
47578 int val3 ;
47579 int ecode3 = 0 ;
47580 int val4 ;
47581 int ecode4 = 0 ;
47582 PyObject * obj0 = 0 ;
47583 PyObject * obj1 = 0 ;
47584 PyObject * obj2 = 0 ;
47585 PyObject * obj3 = 0 ;
47586 char * kwnames[] = {
47587 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47588 };
47589
47590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47591 if (obj0) {
47592 ecode1 = SWIG_AsVal_int(obj0, &val1);
47593 if (!SWIG_IsOK(ecode1)) {
47594 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47595 }
47596 arg1 = static_cast< int >(val1);
47597 }
47598 if (obj1) {
47599 ecode2 = SWIG_AsVal_int(obj1, &val2);
47600 if (!SWIG_IsOK(ecode2)) {
47601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47602 }
47603 arg2 = static_cast< int >(val2);
47604 }
47605 if (obj2) {
47606 ecode3 = SWIG_AsVal_int(obj2, &val3);
47607 if (!SWIG_IsOK(ecode3)) {
47608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47609 }
47610 arg3 = static_cast< int >(val3);
47611 }
47612 if (obj3) {
47613 ecode4 = SWIG_AsVal_int(obj3, &val4);
47614 if (!SWIG_IsOK(ecode4)) {
47615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47616 }
47617 arg4 = static_cast< int >(val4);
47618 }
47619 {
47620 PyThreadState* __tstate = wxPyBeginAllowThreads();
47621 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47622 wxPyEndAllowThreads(__tstate);
47623 if (PyErr_Occurred()) SWIG_fail;
47624 }
47625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47626 return resultobj;
47627 fail:
47628 return NULL;
47629 }
47630
47631
47632 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47633 PyObject *resultobj = 0;
47634 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47635 int arg2 ;
47636 void *argp1 = 0 ;
47637 int res1 = 0 ;
47638 int val2 ;
47639 int ecode2 = 0 ;
47640 PyObject * obj0 = 0 ;
47641 PyObject * obj1 = 0 ;
47642 char * kwnames[] = {
47643 (char *) "self",(char *) "cols", NULL
47644 };
47645
47646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47648 if (!SWIG_IsOK(res1)) {
47649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47650 }
47651 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47652 ecode2 = SWIG_AsVal_int(obj1, &val2);
47653 if (!SWIG_IsOK(ecode2)) {
47654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47655 }
47656 arg2 = static_cast< int >(val2);
47657 {
47658 PyThreadState* __tstate = wxPyBeginAllowThreads();
47659 (arg1)->SetCols(arg2);
47660 wxPyEndAllowThreads(__tstate);
47661 if (PyErr_Occurred()) SWIG_fail;
47662 }
47663 resultobj = SWIG_Py_Void();
47664 return resultobj;
47665 fail:
47666 return NULL;
47667 }
47668
47669
47670 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47671 PyObject *resultobj = 0;
47672 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47673 int arg2 ;
47674 void *argp1 = 0 ;
47675 int res1 = 0 ;
47676 int val2 ;
47677 int ecode2 = 0 ;
47678 PyObject * obj0 = 0 ;
47679 PyObject * obj1 = 0 ;
47680 char * kwnames[] = {
47681 (char *) "self",(char *) "rows", NULL
47682 };
47683
47684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47686 if (!SWIG_IsOK(res1)) {
47687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47688 }
47689 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47690 ecode2 = SWIG_AsVal_int(obj1, &val2);
47691 if (!SWIG_IsOK(ecode2)) {
47692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47693 }
47694 arg2 = static_cast< int >(val2);
47695 {
47696 PyThreadState* __tstate = wxPyBeginAllowThreads();
47697 (arg1)->SetRows(arg2);
47698 wxPyEndAllowThreads(__tstate);
47699 if (PyErr_Occurred()) SWIG_fail;
47700 }
47701 resultobj = SWIG_Py_Void();
47702 return resultobj;
47703 fail:
47704 return NULL;
47705 }
47706
47707
47708 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47709 PyObject *resultobj = 0;
47710 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47711 int arg2 ;
47712 void *argp1 = 0 ;
47713 int res1 = 0 ;
47714 int val2 ;
47715 int ecode2 = 0 ;
47716 PyObject * obj0 = 0 ;
47717 PyObject * obj1 = 0 ;
47718 char * kwnames[] = {
47719 (char *) "self",(char *) "gap", NULL
47720 };
47721
47722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47724 if (!SWIG_IsOK(res1)) {
47725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47726 }
47727 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47728 ecode2 = SWIG_AsVal_int(obj1, &val2);
47729 if (!SWIG_IsOK(ecode2)) {
47730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47731 }
47732 arg2 = static_cast< int >(val2);
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 (arg1)->SetVGap(arg2);
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 resultobj = SWIG_Py_Void();
47740 return resultobj;
47741 fail:
47742 return NULL;
47743 }
47744
47745
47746 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47747 PyObject *resultobj = 0;
47748 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47749 int arg2 ;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 int val2 ;
47753 int ecode2 = 0 ;
47754 PyObject * obj0 = 0 ;
47755 PyObject * obj1 = 0 ;
47756 char * kwnames[] = {
47757 (char *) "self",(char *) "gap", NULL
47758 };
47759
47760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47762 if (!SWIG_IsOK(res1)) {
47763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47764 }
47765 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47766 ecode2 = SWIG_AsVal_int(obj1, &val2);
47767 if (!SWIG_IsOK(ecode2)) {
47768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47769 }
47770 arg2 = static_cast< int >(val2);
47771 {
47772 PyThreadState* __tstate = wxPyBeginAllowThreads();
47773 (arg1)->SetHGap(arg2);
47774 wxPyEndAllowThreads(__tstate);
47775 if (PyErr_Occurred()) SWIG_fail;
47776 }
47777 resultobj = SWIG_Py_Void();
47778 return resultobj;
47779 fail:
47780 return NULL;
47781 }
47782
47783
47784 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47785 PyObject *resultobj = 0;
47786 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47787 int result;
47788 void *argp1 = 0 ;
47789 int res1 = 0 ;
47790 PyObject *swig_obj[1] ;
47791
47792 if (!args) SWIG_fail;
47793 swig_obj[0] = args;
47794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47795 if (!SWIG_IsOK(res1)) {
47796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47797 }
47798 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47799 {
47800 PyThreadState* __tstate = wxPyBeginAllowThreads();
47801 result = (int)(arg1)->GetCols();
47802 wxPyEndAllowThreads(__tstate);
47803 if (PyErr_Occurred()) SWIG_fail;
47804 }
47805 resultobj = SWIG_From_int(static_cast< int >(result));
47806 return resultobj;
47807 fail:
47808 return NULL;
47809 }
47810
47811
47812 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47813 PyObject *resultobj = 0;
47814 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47815 int result;
47816 void *argp1 = 0 ;
47817 int res1 = 0 ;
47818 PyObject *swig_obj[1] ;
47819
47820 if (!args) SWIG_fail;
47821 swig_obj[0] = args;
47822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47823 if (!SWIG_IsOK(res1)) {
47824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47825 }
47826 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47827 {
47828 PyThreadState* __tstate = wxPyBeginAllowThreads();
47829 result = (int)(arg1)->GetRows();
47830 wxPyEndAllowThreads(__tstate);
47831 if (PyErr_Occurred()) SWIG_fail;
47832 }
47833 resultobj = SWIG_From_int(static_cast< int >(result));
47834 return resultobj;
47835 fail:
47836 return NULL;
47837 }
47838
47839
47840 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47841 PyObject *resultobj = 0;
47842 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47843 int result;
47844 void *argp1 = 0 ;
47845 int res1 = 0 ;
47846 PyObject *swig_obj[1] ;
47847
47848 if (!args) SWIG_fail;
47849 swig_obj[0] = args;
47850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47851 if (!SWIG_IsOK(res1)) {
47852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47853 }
47854 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47855 {
47856 PyThreadState* __tstate = wxPyBeginAllowThreads();
47857 result = (int)(arg1)->GetVGap();
47858 wxPyEndAllowThreads(__tstate);
47859 if (PyErr_Occurred()) SWIG_fail;
47860 }
47861 resultobj = SWIG_From_int(static_cast< int >(result));
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47869 PyObject *resultobj = 0;
47870 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47871 int result;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 PyObject *swig_obj[1] ;
47875
47876 if (!args) SWIG_fail;
47877 swig_obj[0] = args;
47878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47879 if (!SWIG_IsOK(res1)) {
47880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47881 }
47882 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47883 {
47884 PyThreadState* __tstate = wxPyBeginAllowThreads();
47885 result = (int)(arg1)->GetHGap();
47886 wxPyEndAllowThreads(__tstate);
47887 if (PyErr_Occurred()) SWIG_fail;
47888 }
47889 resultobj = SWIG_From_int(static_cast< int >(result));
47890 return resultobj;
47891 fail:
47892 return NULL;
47893 }
47894
47895
47896 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47897 PyObject *obj;
47898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47899 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47900 return SWIG_Py_Void();
47901 }
47902
47903 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47904 return SWIG_Python_InitShadowInstance(args);
47905 }
47906
47907 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47908 PyObject *resultobj = 0;
47909 int arg1 = (int) 1 ;
47910 int arg2 = (int) 0 ;
47911 int arg3 = (int) 0 ;
47912 int arg4 = (int) 0 ;
47913 wxFlexGridSizer *result = 0 ;
47914 int val1 ;
47915 int ecode1 = 0 ;
47916 int val2 ;
47917 int ecode2 = 0 ;
47918 int val3 ;
47919 int ecode3 = 0 ;
47920 int val4 ;
47921 int ecode4 = 0 ;
47922 PyObject * obj0 = 0 ;
47923 PyObject * obj1 = 0 ;
47924 PyObject * obj2 = 0 ;
47925 PyObject * obj3 = 0 ;
47926 char * kwnames[] = {
47927 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47928 };
47929
47930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47931 if (obj0) {
47932 ecode1 = SWIG_AsVal_int(obj0, &val1);
47933 if (!SWIG_IsOK(ecode1)) {
47934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47935 }
47936 arg1 = static_cast< int >(val1);
47937 }
47938 if (obj1) {
47939 ecode2 = SWIG_AsVal_int(obj1, &val2);
47940 if (!SWIG_IsOK(ecode2)) {
47941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47942 }
47943 arg2 = static_cast< int >(val2);
47944 }
47945 if (obj2) {
47946 ecode3 = SWIG_AsVal_int(obj2, &val3);
47947 if (!SWIG_IsOK(ecode3)) {
47948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47949 }
47950 arg3 = static_cast< int >(val3);
47951 }
47952 if (obj3) {
47953 ecode4 = SWIG_AsVal_int(obj3, &val4);
47954 if (!SWIG_IsOK(ecode4)) {
47955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47956 }
47957 arg4 = static_cast< int >(val4);
47958 }
47959 {
47960 PyThreadState* __tstate = wxPyBeginAllowThreads();
47961 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47962 wxPyEndAllowThreads(__tstate);
47963 if (PyErr_Occurred()) SWIG_fail;
47964 }
47965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47966 return resultobj;
47967 fail:
47968 return NULL;
47969 }
47970
47971
47972 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47973 PyObject *resultobj = 0;
47974 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47975 size_t arg2 ;
47976 int arg3 = (int) 0 ;
47977 void *argp1 = 0 ;
47978 int res1 = 0 ;
47979 size_t val2 ;
47980 int ecode2 = 0 ;
47981 int val3 ;
47982 int ecode3 = 0 ;
47983 PyObject * obj0 = 0 ;
47984 PyObject * obj1 = 0 ;
47985 PyObject * obj2 = 0 ;
47986 char * kwnames[] = {
47987 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47988 };
47989
47990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47992 if (!SWIG_IsOK(res1)) {
47993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47994 }
47995 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47996 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47997 if (!SWIG_IsOK(ecode2)) {
47998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47999 }
48000 arg2 = static_cast< size_t >(val2);
48001 if (obj2) {
48002 ecode3 = SWIG_AsVal_int(obj2, &val3);
48003 if (!SWIG_IsOK(ecode3)) {
48004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48005 }
48006 arg3 = static_cast< int >(val3);
48007 }
48008 {
48009 PyThreadState* __tstate = wxPyBeginAllowThreads();
48010 (arg1)->AddGrowableRow(arg2,arg3);
48011 wxPyEndAllowThreads(__tstate);
48012 if (PyErr_Occurred()) SWIG_fail;
48013 }
48014 resultobj = SWIG_Py_Void();
48015 return resultobj;
48016 fail:
48017 return NULL;
48018 }
48019
48020
48021 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48022 PyObject *resultobj = 0;
48023 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48024 size_t arg2 ;
48025 void *argp1 = 0 ;
48026 int res1 = 0 ;
48027 size_t val2 ;
48028 int ecode2 = 0 ;
48029 PyObject * obj0 = 0 ;
48030 PyObject * obj1 = 0 ;
48031 char * kwnames[] = {
48032 (char *) "self",(char *) "idx", NULL
48033 };
48034
48035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48037 if (!SWIG_IsOK(res1)) {
48038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48039 }
48040 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48041 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48042 if (!SWIG_IsOK(ecode2)) {
48043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48044 }
48045 arg2 = static_cast< size_t >(val2);
48046 {
48047 PyThreadState* __tstate = wxPyBeginAllowThreads();
48048 (arg1)->RemoveGrowableRow(arg2);
48049 wxPyEndAllowThreads(__tstate);
48050 if (PyErr_Occurred()) SWIG_fail;
48051 }
48052 resultobj = SWIG_Py_Void();
48053 return resultobj;
48054 fail:
48055 return NULL;
48056 }
48057
48058
48059 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48060 PyObject *resultobj = 0;
48061 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48062 size_t arg2 ;
48063 int arg3 = (int) 0 ;
48064 void *argp1 = 0 ;
48065 int res1 = 0 ;
48066 size_t val2 ;
48067 int ecode2 = 0 ;
48068 int val3 ;
48069 int ecode3 = 0 ;
48070 PyObject * obj0 = 0 ;
48071 PyObject * obj1 = 0 ;
48072 PyObject * obj2 = 0 ;
48073 char * kwnames[] = {
48074 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48075 };
48076
48077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48079 if (!SWIG_IsOK(res1)) {
48080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48081 }
48082 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48083 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48084 if (!SWIG_IsOK(ecode2)) {
48085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48086 }
48087 arg2 = static_cast< size_t >(val2);
48088 if (obj2) {
48089 ecode3 = SWIG_AsVal_int(obj2, &val3);
48090 if (!SWIG_IsOK(ecode3)) {
48091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48092 }
48093 arg3 = static_cast< int >(val3);
48094 }
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 (arg1)->AddGrowableCol(arg2,arg3);
48098 wxPyEndAllowThreads(__tstate);
48099 if (PyErr_Occurred()) SWIG_fail;
48100 }
48101 resultobj = SWIG_Py_Void();
48102 return resultobj;
48103 fail:
48104 return NULL;
48105 }
48106
48107
48108 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48109 PyObject *resultobj = 0;
48110 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48111 size_t arg2 ;
48112 void *argp1 = 0 ;
48113 int res1 = 0 ;
48114 size_t val2 ;
48115 int ecode2 = 0 ;
48116 PyObject * obj0 = 0 ;
48117 PyObject * obj1 = 0 ;
48118 char * kwnames[] = {
48119 (char *) "self",(char *) "idx", NULL
48120 };
48121
48122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48124 if (!SWIG_IsOK(res1)) {
48125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48126 }
48127 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48128 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48129 if (!SWIG_IsOK(ecode2)) {
48130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48131 }
48132 arg2 = static_cast< size_t >(val2);
48133 {
48134 PyThreadState* __tstate = wxPyBeginAllowThreads();
48135 (arg1)->RemoveGrowableCol(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_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48147 PyObject *resultobj = 0;
48148 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48149 int arg2 ;
48150 void *argp1 = 0 ;
48151 int res1 = 0 ;
48152 int val2 ;
48153 int ecode2 = 0 ;
48154 PyObject * obj0 = 0 ;
48155 PyObject * obj1 = 0 ;
48156 char * kwnames[] = {
48157 (char *) "self",(char *) "direction", NULL
48158 };
48159
48160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48162 if (!SWIG_IsOK(res1)) {
48163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48164 }
48165 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48166 ecode2 = SWIG_AsVal_int(obj1, &val2);
48167 if (!SWIG_IsOK(ecode2)) {
48168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48169 }
48170 arg2 = static_cast< int >(val2);
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 (arg1)->SetFlexibleDirection(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_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48185 PyObject *resultobj = 0;
48186 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48187 int result;
48188 void *argp1 = 0 ;
48189 int res1 = 0 ;
48190 PyObject *swig_obj[1] ;
48191
48192 if (!args) SWIG_fail;
48193 swig_obj[0] = args;
48194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48197 }
48198 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48199 {
48200 PyThreadState* __tstate = wxPyBeginAllowThreads();
48201 result = (int)(arg1)->GetFlexibleDirection();
48202 wxPyEndAllowThreads(__tstate);
48203 if (PyErr_Occurred()) SWIG_fail;
48204 }
48205 resultobj = SWIG_From_int(static_cast< int >(result));
48206 return resultobj;
48207 fail:
48208 return NULL;
48209 }
48210
48211
48212 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48213 PyObject *resultobj = 0;
48214 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48215 wxFlexSizerGrowMode arg2 ;
48216 void *argp1 = 0 ;
48217 int res1 = 0 ;
48218 int val2 ;
48219 int ecode2 = 0 ;
48220 PyObject * obj0 = 0 ;
48221 PyObject * obj1 = 0 ;
48222 char * kwnames[] = {
48223 (char *) "self",(char *) "mode", NULL
48224 };
48225
48226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48228 if (!SWIG_IsOK(res1)) {
48229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48230 }
48231 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48232 ecode2 = SWIG_AsVal_int(obj1, &val2);
48233 if (!SWIG_IsOK(ecode2)) {
48234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48235 }
48236 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48237 {
48238 PyThreadState* __tstate = wxPyBeginAllowThreads();
48239 (arg1)->SetNonFlexibleGrowMode(arg2);
48240 wxPyEndAllowThreads(__tstate);
48241 if (PyErr_Occurred()) SWIG_fail;
48242 }
48243 resultobj = SWIG_Py_Void();
48244 return resultobj;
48245 fail:
48246 return NULL;
48247 }
48248
48249
48250 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48251 PyObject *resultobj = 0;
48252 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48253 wxFlexSizerGrowMode result;
48254 void *argp1 = 0 ;
48255 int res1 = 0 ;
48256 PyObject *swig_obj[1] ;
48257
48258 if (!args) SWIG_fail;
48259 swig_obj[0] = args;
48260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48261 if (!SWIG_IsOK(res1)) {
48262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48263 }
48264 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48265 {
48266 PyThreadState* __tstate = wxPyBeginAllowThreads();
48267 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48268 wxPyEndAllowThreads(__tstate);
48269 if (PyErr_Occurred()) SWIG_fail;
48270 }
48271 resultobj = SWIG_From_int(static_cast< int >(result));
48272 return resultobj;
48273 fail:
48274 return NULL;
48275 }
48276
48277
48278 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48279 PyObject *resultobj = 0;
48280 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48281 wxArrayInt *result = 0 ;
48282 void *argp1 = 0 ;
48283 int res1 = 0 ;
48284 PyObject *swig_obj[1] ;
48285
48286 if (!args) SWIG_fail;
48287 swig_obj[0] = args;
48288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48289 if (!SWIG_IsOK(res1)) {
48290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48291 }
48292 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48293 {
48294 PyThreadState* __tstate = wxPyBeginAllowThreads();
48295 {
48296 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48297 result = (wxArrayInt *) &_result_ref;
48298 }
48299 wxPyEndAllowThreads(__tstate);
48300 if (PyErr_Occurred()) SWIG_fail;
48301 }
48302 {
48303 resultobj = PyList_New(0);
48304 size_t idx;
48305 for (idx = 0; idx < result->GetCount(); idx += 1) {
48306 PyObject* val = PyInt_FromLong( result->Item(idx) );
48307 PyList_Append(resultobj, val);
48308 Py_DECREF(val);
48309 }
48310 }
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48318 PyObject *resultobj = 0;
48319 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48320 wxArrayInt *result = 0 ;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 PyObject *swig_obj[1] ;
48324
48325 if (!args) SWIG_fail;
48326 swig_obj[0] = args;
48327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48328 if (!SWIG_IsOK(res1)) {
48329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48330 }
48331 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 {
48335 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48336 result = (wxArrayInt *) &_result_ref;
48337 }
48338 wxPyEndAllowThreads(__tstate);
48339 if (PyErr_Occurred()) SWIG_fail;
48340 }
48341 {
48342 resultobj = PyList_New(0);
48343 size_t idx;
48344 for (idx = 0; idx < result->GetCount(); idx += 1) {
48345 PyObject* val = PyInt_FromLong( result->Item(idx) );
48346 PyList_Append(resultobj, val);
48347 Py_DECREF(val);
48348 }
48349 }
48350 return resultobj;
48351 fail:
48352 return NULL;
48353 }
48354
48355
48356 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48357 PyObject *obj;
48358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48359 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48360 return SWIG_Py_Void();
48361 }
48362
48363 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48364 return SWIG_Python_InitShadowInstance(args);
48365 }
48366
48367 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48368 PyObject *resultobj = 0;
48369 wxStdDialogButtonSizer *result = 0 ;
48370
48371 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48372 {
48373 PyThreadState* __tstate = wxPyBeginAllowThreads();
48374 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48375 wxPyEndAllowThreads(__tstate);
48376 if (PyErr_Occurred()) SWIG_fail;
48377 }
48378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48379 return resultobj;
48380 fail:
48381 return NULL;
48382 }
48383
48384
48385 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48386 PyObject *resultobj = 0;
48387 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48388 wxButton *arg2 = (wxButton *) 0 ;
48389 void *argp1 = 0 ;
48390 int res1 = 0 ;
48391 void *argp2 = 0 ;
48392 int res2 = 0 ;
48393 PyObject * obj0 = 0 ;
48394 PyObject * obj1 = 0 ;
48395 char * kwnames[] = {
48396 (char *) "self",(char *) "button", NULL
48397 };
48398
48399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48401 if (!SWIG_IsOK(res1)) {
48402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48403 }
48404 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48406 if (!SWIG_IsOK(res2)) {
48407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48408 }
48409 arg2 = reinterpret_cast< wxButton * >(argp2);
48410 {
48411 PyThreadState* __tstate = wxPyBeginAllowThreads();
48412 (arg1)->AddButton(arg2);
48413 wxPyEndAllowThreads(__tstate);
48414 if (PyErr_Occurred()) SWIG_fail;
48415 }
48416 resultobj = SWIG_Py_Void();
48417 return resultobj;
48418 fail:
48419 return NULL;
48420 }
48421
48422
48423 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48424 PyObject *resultobj = 0;
48425 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48426 void *argp1 = 0 ;
48427 int res1 = 0 ;
48428 PyObject *swig_obj[1] ;
48429
48430 if (!args) SWIG_fail;
48431 swig_obj[0] = args;
48432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48433 if (!SWIG_IsOK(res1)) {
48434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48435 }
48436 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48437 {
48438 PyThreadState* __tstate = wxPyBeginAllowThreads();
48439 (arg1)->Realize();
48440 wxPyEndAllowThreads(__tstate);
48441 if (PyErr_Occurred()) SWIG_fail;
48442 }
48443 resultobj = SWIG_Py_Void();
48444 return resultobj;
48445 fail:
48446 return NULL;
48447 }
48448
48449
48450 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48451 PyObject *resultobj = 0;
48452 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48453 wxButton *arg2 = (wxButton *) 0 ;
48454 void *argp1 = 0 ;
48455 int res1 = 0 ;
48456 void *argp2 = 0 ;
48457 int res2 = 0 ;
48458 PyObject * obj0 = 0 ;
48459 PyObject * obj1 = 0 ;
48460 char * kwnames[] = {
48461 (char *) "self",(char *) "button", NULL
48462 };
48463
48464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48466 if (!SWIG_IsOK(res1)) {
48467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48468 }
48469 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48471 if (!SWIG_IsOK(res2)) {
48472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48473 }
48474 arg2 = reinterpret_cast< wxButton * >(argp2);
48475 {
48476 PyThreadState* __tstate = wxPyBeginAllowThreads();
48477 (arg1)->SetAffirmativeButton(arg2);
48478 wxPyEndAllowThreads(__tstate);
48479 if (PyErr_Occurred()) SWIG_fail;
48480 }
48481 resultobj = SWIG_Py_Void();
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48489 PyObject *resultobj = 0;
48490 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48491 wxButton *arg2 = (wxButton *) 0 ;
48492 void *argp1 = 0 ;
48493 int res1 = 0 ;
48494 void *argp2 = 0 ;
48495 int res2 = 0 ;
48496 PyObject * obj0 = 0 ;
48497 PyObject * obj1 = 0 ;
48498 char * kwnames[] = {
48499 (char *) "self",(char *) "button", NULL
48500 };
48501
48502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48504 if (!SWIG_IsOK(res1)) {
48505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48506 }
48507 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48509 if (!SWIG_IsOK(res2)) {
48510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48511 }
48512 arg2 = reinterpret_cast< wxButton * >(argp2);
48513 {
48514 PyThreadState* __tstate = wxPyBeginAllowThreads();
48515 (arg1)->SetNegativeButton(arg2);
48516 wxPyEndAllowThreads(__tstate);
48517 if (PyErr_Occurred()) SWIG_fail;
48518 }
48519 resultobj = SWIG_Py_Void();
48520 return resultobj;
48521 fail:
48522 return NULL;
48523 }
48524
48525
48526 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48527 PyObject *resultobj = 0;
48528 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48529 wxButton *arg2 = (wxButton *) 0 ;
48530 void *argp1 = 0 ;
48531 int res1 = 0 ;
48532 void *argp2 = 0 ;
48533 int res2 = 0 ;
48534 PyObject * obj0 = 0 ;
48535 PyObject * obj1 = 0 ;
48536 char * kwnames[] = {
48537 (char *) "self",(char *) "button", NULL
48538 };
48539
48540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48542 if (!SWIG_IsOK(res1)) {
48543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48544 }
48545 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48547 if (!SWIG_IsOK(res2)) {
48548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48549 }
48550 arg2 = reinterpret_cast< wxButton * >(argp2);
48551 {
48552 PyThreadState* __tstate = wxPyBeginAllowThreads();
48553 (arg1)->SetCancelButton(arg2);
48554 wxPyEndAllowThreads(__tstate);
48555 if (PyErr_Occurred()) SWIG_fail;
48556 }
48557 resultobj = SWIG_Py_Void();
48558 return resultobj;
48559 fail:
48560 return NULL;
48561 }
48562
48563
48564 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48565 PyObject *resultobj = 0;
48566 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48567 wxButton *result = 0 ;
48568 void *argp1 = 0 ;
48569 int res1 = 0 ;
48570 PyObject *swig_obj[1] ;
48571
48572 if (!args) SWIG_fail;
48573 swig_obj[0] = args;
48574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48575 if (!SWIG_IsOK(res1)) {
48576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48577 }
48578 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48579 {
48580 PyThreadState* __tstate = wxPyBeginAllowThreads();
48581 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48582 wxPyEndAllowThreads(__tstate);
48583 if (PyErr_Occurred()) SWIG_fail;
48584 }
48585 {
48586 resultobj = wxPyMake_wxObject(result, (bool)0);
48587 }
48588 return resultobj;
48589 fail:
48590 return NULL;
48591 }
48592
48593
48594 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48595 PyObject *resultobj = 0;
48596 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48597 wxButton *result = 0 ;
48598 void *argp1 = 0 ;
48599 int res1 = 0 ;
48600 PyObject *swig_obj[1] ;
48601
48602 if (!args) SWIG_fail;
48603 swig_obj[0] = args;
48604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48605 if (!SWIG_IsOK(res1)) {
48606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48607 }
48608 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48609 {
48610 PyThreadState* __tstate = wxPyBeginAllowThreads();
48611 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48612 wxPyEndAllowThreads(__tstate);
48613 if (PyErr_Occurred()) SWIG_fail;
48614 }
48615 {
48616 resultobj = wxPyMake_wxObject(result, (bool)0);
48617 }
48618 return resultobj;
48619 fail:
48620 return NULL;
48621 }
48622
48623
48624 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48625 PyObject *resultobj = 0;
48626 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48627 wxButton *result = 0 ;
48628 void *argp1 = 0 ;
48629 int res1 = 0 ;
48630 PyObject *swig_obj[1] ;
48631
48632 if (!args) SWIG_fail;
48633 swig_obj[0] = args;
48634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48635 if (!SWIG_IsOK(res1)) {
48636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48637 }
48638 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48639 {
48640 PyThreadState* __tstate = wxPyBeginAllowThreads();
48641 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48642 wxPyEndAllowThreads(__tstate);
48643 if (PyErr_Occurred()) SWIG_fail;
48644 }
48645 {
48646 resultobj = wxPyMake_wxObject(result, (bool)0);
48647 }
48648 return resultobj;
48649 fail:
48650 return NULL;
48651 }
48652
48653
48654 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48655 PyObject *resultobj = 0;
48656 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48657 wxButton *result = 0 ;
48658 void *argp1 = 0 ;
48659 int res1 = 0 ;
48660 PyObject *swig_obj[1] ;
48661
48662 if (!args) SWIG_fail;
48663 swig_obj[0] = args;
48664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48665 if (!SWIG_IsOK(res1)) {
48666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48667 }
48668 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48669 {
48670 PyThreadState* __tstate = wxPyBeginAllowThreads();
48671 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48672 wxPyEndAllowThreads(__tstate);
48673 if (PyErr_Occurred()) SWIG_fail;
48674 }
48675 {
48676 resultobj = wxPyMake_wxObject(result, (bool)0);
48677 }
48678 return resultobj;
48679 fail:
48680 return NULL;
48681 }
48682
48683
48684 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48685 PyObject *resultobj = 0;
48686 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48687 wxButton *result = 0 ;
48688 void *argp1 = 0 ;
48689 int res1 = 0 ;
48690 PyObject *swig_obj[1] ;
48691
48692 if (!args) SWIG_fail;
48693 swig_obj[0] = args;
48694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48695 if (!SWIG_IsOK(res1)) {
48696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48697 }
48698 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48699 {
48700 PyThreadState* __tstate = wxPyBeginAllowThreads();
48701 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48702 wxPyEndAllowThreads(__tstate);
48703 if (PyErr_Occurred()) SWIG_fail;
48704 }
48705 {
48706 resultobj = wxPyMake_wxObject(result, (bool)0);
48707 }
48708 return resultobj;
48709 fail:
48710 return NULL;
48711 }
48712
48713
48714 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48715 PyObject *obj;
48716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48717 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48718 return SWIG_Py_Void();
48719 }
48720
48721 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48722 return SWIG_Python_InitShadowInstance(args);
48723 }
48724
48725 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48726 PyObject *resultobj = 0;
48727 int arg1 = (int) 0 ;
48728 int arg2 = (int) 0 ;
48729 wxGBPosition *result = 0 ;
48730 int val1 ;
48731 int ecode1 = 0 ;
48732 int val2 ;
48733 int ecode2 = 0 ;
48734 PyObject * obj0 = 0 ;
48735 PyObject * obj1 = 0 ;
48736 char * kwnames[] = {
48737 (char *) "row",(char *) "col", NULL
48738 };
48739
48740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48741 if (obj0) {
48742 ecode1 = SWIG_AsVal_int(obj0, &val1);
48743 if (!SWIG_IsOK(ecode1)) {
48744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48745 }
48746 arg1 = static_cast< int >(val1);
48747 }
48748 if (obj1) {
48749 ecode2 = SWIG_AsVal_int(obj1, &val2);
48750 if (!SWIG_IsOK(ecode2)) {
48751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48752 }
48753 arg2 = static_cast< int >(val2);
48754 }
48755 {
48756 PyThreadState* __tstate = wxPyBeginAllowThreads();
48757 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48758 wxPyEndAllowThreads(__tstate);
48759 if (PyErr_Occurred()) SWIG_fail;
48760 }
48761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48762 return resultobj;
48763 fail:
48764 return NULL;
48765 }
48766
48767
48768 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48769 PyObject *resultobj = 0;
48770 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48771 void *argp1 = 0 ;
48772 int res1 = 0 ;
48773 PyObject *swig_obj[1] ;
48774
48775 if (!args) SWIG_fail;
48776 swig_obj[0] = args;
48777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48778 if (!SWIG_IsOK(res1)) {
48779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48780 }
48781 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48782 {
48783 PyThreadState* __tstate = wxPyBeginAllowThreads();
48784 delete arg1;
48785
48786 wxPyEndAllowThreads(__tstate);
48787 if (PyErr_Occurred()) SWIG_fail;
48788 }
48789 resultobj = SWIG_Py_Void();
48790 return resultobj;
48791 fail:
48792 return NULL;
48793 }
48794
48795
48796 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48797 PyObject *resultobj = 0;
48798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48799 int result;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 PyObject *swig_obj[1] ;
48803
48804 if (!args) SWIG_fail;
48805 swig_obj[0] = args;
48806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48809 }
48810 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48811 {
48812 PyThreadState* __tstate = wxPyBeginAllowThreads();
48813 result = (int)((wxGBPosition const *)arg1)->GetRow();
48814 wxPyEndAllowThreads(__tstate);
48815 if (PyErr_Occurred()) SWIG_fail;
48816 }
48817 resultobj = SWIG_From_int(static_cast< int >(result));
48818 return resultobj;
48819 fail:
48820 return NULL;
48821 }
48822
48823
48824 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48825 PyObject *resultobj = 0;
48826 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48827 int result;
48828 void *argp1 = 0 ;
48829 int res1 = 0 ;
48830 PyObject *swig_obj[1] ;
48831
48832 if (!args) SWIG_fail;
48833 swig_obj[0] = args;
48834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48835 if (!SWIG_IsOK(res1)) {
48836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48837 }
48838 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48839 {
48840 PyThreadState* __tstate = wxPyBeginAllowThreads();
48841 result = (int)((wxGBPosition const *)arg1)->GetCol();
48842 wxPyEndAllowThreads(__tstate);
48843 if (PyErr_Occurred()) SWIG_fail;
48844 }
48845 resultobj = SWIG_From_int(static_cast< int >(result));
48846 return resultobj;
48847 fail:
48848 return NULL;
48849 }
48850
48851
48852 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48853 PyObject *resultobj = 0;
48854 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48855 int arg2 ;
48856 void *argp1 = 0 ;
48857 int res1 = 0 ;
48858 int val2 ;
48859 int ecode2 = 0 ;
48860 PyObject * obj0 = 0 ;
48861 PyObject * obj1 = 0 ;
48862 char * kwnames[] = {
48863 (char *) "self",(char *) "row", NULL
48864 };
48865
48866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48868 if (!SWIG_IsOK(res1)) {
48869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48870 }
48871 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48872 ecode2 = SWIG_AsVal_int(obj1, &val2);
48873 if (!SWIG_IsOK(ecode2)) {
48874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48875 }
48876 arg2 = static_cast< int >(val2);
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 (arg1)->SetRow(arg2);
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 resultobj = SWIG_Py_Void();
48884 return resultobj;
48885 fail:
48886 return NULL;
48887 }
48888
48889
48890 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48891 PyObject *resultobj = 0;
48892 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48893 int arg2 ;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 int val2 ;
48897 int ecode2 = 0 ;
48898 PyObject * obj0 = 0 ;
48899 PyObject * obj1 = 0 ;
48900 char * kwnames[] = {
48901 (char *) "self",(char *) "col", NULL
48902 };
48903
48904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48906 if (!SWIG_IsOK(res1)) {
48907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48908 }
48909 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48910 ecode2 = SWIG_AsVal_int(obj1, &val2);
48911 if (!SWIG_IsOK(ecode2)) {
48912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48913 }
48914 arg2 = static_cast< int >(val2);
48915 {
48916 PyThreadState* __tstate = wxPyBeginAllowThreads();
48917 (arg1)->SetCol(arg2);
48918 wxPyEndAllowThreads(__tstate);
48919 if (PyErr_Occurred()) SWIG_fail;
48920 }
48921 resultobj = SWIG_Py_Void();
48922 return resultobj;
48923 fail:
48924 return NULL;
48925 }
48926
48927
48928 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48929 PyObject *resultobj = 0;
48930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48931 PyObject *arg2 = (PyObject *) 0 ;
48932 bool result;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 PyObject * obj0 = 0 ;
48936 PyObject * obj1 = 0 ;
48937 char * kwnames[] = {
48938 (char *) "self",(char *) "other", NULL
48939 };
48940
48941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48945 }
48946 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48947 arg2 = obj1;
48948 {
48949 result = (bool)wxGBPosition___eq__(arg1,arg2);
48950 if (PyErr_Occurred()) SWIG_fail;
48951 }
48952 {
48953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48954 }
48955 return resultobj;
48956 fail:
48957 return NULL;
48958 }
48959
48960
48961 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48962 PyObject *resultobj = 0;
48963 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48964 PyObject *arg2 = (PyObject *) 0 ;
48965 bool result;
48966 void *argp1 = 0 ;
48967 int res1 = 0 ;
48968 PyObject * obj0 = 0 ;
48969 PyObject * obj1 = 0 ;
48970 char * kwnames[] = {
48971 (char *) "self",(char *) "other", NULL
48972 };
48973
48974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48976 if (!SWIG_IsOK(res1)) {
48977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48978 }
48979 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48980 arg2 = obj1;
48981 {
48982 result = (bool)wxGBPosition___ne__(arg1,arg2);
48983 if (PyErr_Occurred()) SWIG_fail;
48984 }
48985 {
48986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48987 }
48988 return resultobj;
48989 fail:
48990 return NULL;
48991 }
48992
48993
48994 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48995 PyObject *resultobj = 0;
48996 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48997 int arg2 = (int) 0 ;
48998 int arg3 = (int) 0 ;
48999 void *argp1 = 0 ;
49000 int res1 = 0 ;
49001 int val2 ;
49002 int ecode2 = 0 ;
49003 int val3 ;
49004 int ecode3 = 0 ;
49005 PyObject * obj0 = 0 ;
49006 PyObject * obj1 = 0 ;
49007 PyObject * obj2 = 0 ;
49008 char * kwnames[] = {
49009 (char *) "self",(char *) "row",(char *) "col", NULL
49010 };
49011
49012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49014 if (!SWIG_IsOK(res1)) {
49015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49016 }
49017 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49018 if (obj1) {
49019 ecode2 = SWIG_AsVal_int(obj1, &val2);
49020 if (!SWIG_IsOK(ecode2)) {
49021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49022 }
49023 arg2 = static_cast< int >(val2);
49024 }
49025 if (obj2) {
49026 ecode3 = SWIG_AsVal_int(obj2, &val3);
49027 if (!SWIG_IsOK(ecode3)) {
49028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49029 }
49030 arg3 = static_cast< int >(val3);
49031 }
49032 {
49033 PyThreadState* __tstate = wxPyBeginAllowThreads();
49034 wxGBPosition_Set(arg1,arg2,arg3);
49035 wxPyEndAllowThreads(__tstate);
49036 if (PyErr_Occurred()) SWIG_fail;
49037 }
49038 resultobj = SWIG_Py_Void();
49039 return resultobj;
49040 fail:
49041 return NULL;
49042 }
49043
49044
49045 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 PyObject *resultobj = 0;
49047 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49048 PyObject *result = 0 ;
49049 void *argp1 = 0 ;
49050 int res1 = 0 ;
49051 PyObject *swig_obj[1] ;
49052
49053 if (!args) SWIG_fail;
49054 swig_obj[0] = args;
49055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49058 }
49059 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 result = (PyObject *)wxGBPosition_Get(arg1);
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 resultobj = result;
49067 return resultobj;
49068 fail:
49069 return NULL;
49070 }
49071
49072
49073 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 PyObject *obj;
49075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49076 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49077 return SWIG_Py_Void();
49078 }
49079
49080 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49081 return SWIG_Python_InitShadowInstance(args);
49082 }
49083
49084 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49085 PyObject *resultobj = 0;
49086 int arg1 = (int) 1 ;
49087 int arg2 = (int) 1 ;
49088 wxGBSpan *result = 0 ;
49089 int val1 ;
49090 int ecode1 = 0 ;
49091 int val2 ;
49092 int ecode2 = 0 ;
49093 PyObject * obj0 = 0 ;
49094 PyObject * obj1 = 0 ;
49095 char * kwnames[] = {
49096 (char *) "rowspan",(char *) "colspan", NULL
49097 };
49098
49099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49100 if (obj0) {
49101 ecode1 = SWIG_AsVal_int(obj0, &val1);
49102 if (!SWIG_IsOK(ecode1)) {
49103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49104 }
49105 arg1 = static_cast< int >(val1);
49106 }
49107 if (obj1) {
49108 ecode2 = SWIG_AsVal_int(obj1, &val2);
49109 if (!SWIG_IsOK(ecode2)) {
49110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49111 }
49112 arg2 = static_cast< int >(val2);
49113 }
49114 {
49115 PyThreadState* __tstate = wxPyBeginAllowThreads();
49116 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49128 PyObject *resultobj = 0;
49129 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49130 void *argp1 = 0 ;
49131 int res1 = 0 ;
49132 PyObject *swig_obj[1] ;
49133
49134 if (!args) SWIG_fail;
49135 swig_obj[0] = args;
49136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49137 if (!SWIG_IsOK(res1)) {
49138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49139 }
49140 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49141 {
49142 PyThreadState* __tstate = wxPyBeginAllowThreads();
49143 delete arg1;
49144
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 resultobj = SWIG_Py_Void();
49149 return resultobj;
49150 fail:
49151 return NULL;
49152 }
49153
49154
49155 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49156 PyObject *resultobj = 0;
49157 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49158 int result;
49159 void *argp1 = 0 ;
49160 int res1 = 0 ;
49161 PyObject *swig_obj[1] ;
49162
49163 if (!args) SWIG_fail;
49164 swig_obj[0] = args;
49165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49166 if (!SWIG_IsOK(res1)) {
49167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49168 }
49169 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49170 {
49171 PyThreadState* __tstate = wxPyBeginAllowThreads();
49172 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49173 wxPyEndAllowThreads(__tstate);
49174 if (PyErr_Occurred()) SWIG_fail;
49175 }
49176 resultobj = SWIG_From_int(static_cast< int >(result));
49177 return resultobj;
49178 fail:
49179 return NULL;
49180 }
49181
49182
49183 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49184 PyObject *resultobj = 0;
49185 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49186 int result;
49187 void *argp1 = 0 ;
49188 int res1 = 0 ;
49189 PyObject *swig_obj[1] ;
49190
49191 if (!args) SWIG_fail;
49192 swig_obj[0] = args;
49193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49194 if (!SWIG_IsOK(res1)) {
49195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49196 }
49197 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49198 {
49199 PyThreadState* __tstate = wxPyBeginAllowThreads();
49200 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49201 wxPyEndAllowThreads(__tstate);
49202 if (PyErr_Occurred()) SWIG_fail;
49203 }
49204 resultobj = SWIG_From_int(static_cast< int >(result));
49205 return resultobj;
49206 fail:
49207 return NULL;
49208 }
49209
49210
49211 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49212 PyObject *resultobj = 0;
49213 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49214 int arg2 ;
49215 void *argp1 = 0 ;
49216 int res1 = 0 ;
49217 int val2 ;
49218 int ecode2 = 0 ;
49219 PyObject * obj0 = 0 ;
49220 PyObject * obj1 = 0 ;
49221 char * kwnames[] = {
49222 (char *) "self",(char *) "rowspan", NULL
49223 };
49224
49225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49227 if (!SWIG_IsOK(res1)) {
49228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49229 }
49230 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49231 ecode2 = SWIG_AsVal_int(obj1, &val2);
49232 if (!SWIG_IsOK(ecode2)) {
49233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49234 }
49235 arg2 = static_cast< int >(val2);
49236 {
49237 PyThreadState* __tstate = wxPyBeginAllowThreads();
49238 (arg1)->SetRowspan(arg2);
49239 wxPyEndAllowThreads(__tstate);
49240 if (PyErr_Occurred()) SWIG_fail;
49241 }
49242 resultobj = SWIG_Py_Void();
49243 return resultobj;
49244 fail:
49245 return NULL;
49246 }
49247
49248
49249 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49250 PyObject *resultobj = 0;
49251 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49252 int arg2 ;
49253 void *argp1 = 0 ;
49254 int res1 = 0 ;
49255 int val2 ;
49256 int ecode2 = 0 ;
49257 PyObject * obj0 = 0 ;
49258 PyObject * obj1 = 0 ;
49259 char * kwnames[] = {
49260 (char *) "self",(char *) "colspan", NULL
49261 };
49262
49263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49265 if (!SWIG_IsOK(res1)) {
49266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49267 }
49268 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49269 ecode2 = SWIG_AsVal_int(obj1, &val2);
49270 if (!SWIG_IsOK(ecode2)) {
49271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49272 }
49273 arg2 = static_cast< int >(val2);
49274 {
49275 PyThreadState* __tstate = wxPyBeginAllowThreads();
49276 (arg1)->SetColspan(arg2);
49277 wxPyEndAllowThreads(__tstate);
49278 if (PyErr_Occurred()) SWIG_fail;
49279 }
49280 resultobj = SWIG_Py_Void();
49281 return resultobj;
49282 fail:
49283 return NULL;
49284 }
49285
49286
49287 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49288 PyObject *resultobj = 0;
49289 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49290 PyObject *arg2 = (PyObject *) 0 ;
49291 bool result;
49292 void *argp1 = 0 ;
49293 int res1 = 0 ;
49294 PyObject * obj0 = 0 ;
49295 PyObject * obj1 = 0 ;
49296 char * kwnames[] = {
49297 (char *) "self",(char *) "other", NULL
49298 };
49299
49300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49302 if (!SWIG_IsOK(res1)) {
49303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49304 }
49305 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49306 arg2 = obj1;
49307 {
49308 result = (bool)wxGBSpan___eq__(arg1,arg2);
49309 if (PyErr_Occurred()) SWIG_fail;
49310 }
49311 {
49312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49313 }
49314 return resultobj;
49315 fail:
49316 return NULL;
49317 }
49318
49319
49320 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49321 PyObject *resultobj = 0;
49322 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49323 PyObject *arg2 = (PyObject *) 0 ;
49324 bool result;
49325 void *argp1 = 0 ;
49326 int res1 = 0 ;
49327 PyObject * obj0 = 0 ;
49328 PyObject * obj1 = 0 ;
49329 char * kwnames[] = {
49330 (char *) "self",(char *) "other", NULL
49331 };
49332
49333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49335 if (!SWIG_IsOK(res1)) {
49336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49337 }
49338 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49339 arg2 = obj1;
49340 {
49341 result = (bool)wxGBSpan___ne__(arg1,arg2);
49342 if (PyErr_Occurred()) SWIG_fail;
49343 }
49344 {
49345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49346 }
49347 return resultobj;
49348 fail:
49349 return NULL;
49350 }
49351
49352
49353 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49354 PyObject *resultobj = 0;
49355 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49356 int arg2 = (int) 1 ;
49357 int arg3 = (int) 1 ;
49358 void *argp1 = 0 ;
49359 int res1 = 0 ;
49360 int val2 ;
49361 int ecode2 = 0 ;
49362 int val3 ;
49363 int ecode3 = 0 ;
49364 PyObject * obj0 = 0 ;
49365 PyObject * obj1 = 0 ;
49366 PyObject * obj2 = 0 ;
49367 char * kwnames[] = {
49368 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49369 };
49370
49371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49373 if (!SWIG_IsOK(res1)) {
49374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49375 }
49376 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49377 if (obj1) {
49378 ecode2 = SWIG_AsVal_int(obj1, &val2);
49379 if (!SWIG_IsOK(ecode2)) {
49380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49381 }
49382 arg2 = static_cast< int >(val2);
49383 }
49384 if (obj2) {
49385 ecode3 = SWIG_AsVal_int(obj2, &val3);
49386 if (!SWIG_IsOK(ecode3)) {
49387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49388 }
49389 arg3 = static_cast< int >(val3);
49390 }
49391 {
49392 PyThreadState* __tstate = wxPyBeginAllowThreads();
49393 wxGBSpan_Set(arg1,arg2,arg3);
49394 wxPyEndAllowThreads(__tstate);
49395 if (PyErr_Occurred()) SWIG_fail;
49396 }
49397 resultobj = SWIG_Py_Void();
49398 return resultobj;
49399 fail:
49400 return NULL;
49401 }
49402
49403
49404 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49405 PyObject *resultobj = 0;
49406 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49407 PyObject *result = 0 ;
49408 void *argp1 = 0 ;
49409 int res1 = 0 ;
49410 PyObject *swig_obj[1] ;
49411
49412 if (!args) SWIG_fail;
49413 swig_obj[0] = args;
49414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49415 if (!SWIG_IsOK(res1)) {
49416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49417 }
49418 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49419 {
49420 PyThreadState* __tstate = wxPyBeginAllowThreads();
49421 result = (PyObject *)wxGBSpan_Get(arg1);
49422 wxPyEndAllowThreads(__tstate);
49423 if (PyErr_Occurred()) SWIG_fail;
49424 }
49425 resultobj = result;
49426 return resultobj;
49427 fail:
49428 return NULL;
49429 }
49430
49431
49432 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49433 PyObject *obj;
49434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49435 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49436 return SWIG_Py_Void();
49437 }
49438
49439 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49440 return SWIG_Python_InitShadowInstance(args);
49441 }
49442
49443 SWIGINTERN int DefaultSpan_set(PyObject *) {
49444 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49445 return 1;
49446 }
49447
49448
49449 SWIGINTERN PyObject *DefaultSpan_get(void) {
49450 PyObject *pyobj = 0;
49451
49452 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49453 return pyobj;
49454 }
49455
49456
49457 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49458 PyObject *resultobj = 0;
49459 wxGBSizerItem *result = 0 ;
49460
49461 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49462 {
49463 PyThreadState* __tstate = wxPyBeginAllowThreads();
49464 result = (wxGBSizerItem *)new wxGBSizerItem();
49465 wxPyEndAllowThreads(__tstate);
49466 if (PyErr_Occurred()) SWIG_fail;
49467 }
49468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49469 return resultobj;
49470 fail:
49471 return NULL;
49472 }
49473
49474
49475 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49476 PyObject *resultobj = 0;
49477 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49478 void *argp1 = 0 ;
49479 int res1 = 0 ;
49480 PyObject *swig_obj[1] ;
49481
49482 if (!args) SWIG_fail;
49483 swig_obj[0] = args;
49484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49485 if (!SWIG_IsOK(res1)) {
49486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49487 }
49488 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49489 {
49490 PyThreadState* __tstate = wxPyBeginAllowThreads();
49491 delete arg1;
49492
49493 wxPyEndAllowThreads(__tstate);
49494 if (PyErr_Occurred()) SWIG_fail;
49495 }
49496 resultobj = SWIG_Py_Void();
49497 return resultobj;
49498 fail:
49499 return NULL;
49500 }
49501
49502
49503 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49504 PyObject *resultobj = 0;
49505 wxWindow *arg1 = (wxWindow *) 0 ;
49506 wxGBPosition *arg2 = 0 ;
49507 wxGBSpan *arg3 = 0 ;
49508 int arg4 ;
49509 int arg5 ;
49510 PyObject *arg6 = (PyObject *) NULL ;
49511 wxGBSizerItem *result = 0 ;
49512 void *argp1 = 0 ;
49513 int res1 = 0 ;
49514 wxGBPosition temp2 ;
49515 wxGBSpan temp3 ;
49516 int val4 ;
49517 int ecode4 = 0 ;
49518 int val5 ;
49519 int ecode5 = 0 ;
49520 PyObject * obj0 = 0 ;
49521 PyObject * obj1 = 0 ;
49522 PyObject * obj2 = 0 ;
49523 PyObject * obj3 = 0 ;
49524 PyObject * obj4 = 0 ;
49525 PyObject * obj5 = 0 ;
49526 char * kwnames[] = {
49527 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49528 };
49529
49530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49532 if (!SWIG_IsOK(res1)) {
49533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49534 }
49535 arg1 = reinterpret_cast< wxWindow * >(argp1);
49536 {
49537 arg2 = &temp2;
49538 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49539 }
49540 {
49541 arg3 = &temp3;
49542 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49543 }
49544 ecode4 = SWIG_AsVal_int(obj3, &val4);
49545 if (!SWIG_IsOK(ecode4)) {
49546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49547 }
49548 arg4 = static_cast< int >(val4);
49549 ecode5 = SWIG_AsVal_int(obj4, &val5);
49550 if (!SWIG_IsOK(ecode5)) {
49551 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49552 }
49553 arg5 = static_cast< int >(val5);
49554 if (obj5) {
49555 arg6 = obj5;
49556 }
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49571 PyObject *resultobj = 0;
49572 wxSizer *arg1 = (wxSizer *) 0 ;
49573 wxGBPosition *arg2 = 0 ;
49574 wxGBSpan *arg3 = 0 ;
49575 int arg4 ;
49576 int arg5 ;
49577 PyObject *arg6 = (PyObject *) NULL ;
49578 wxGBSizerItem *result = 0 ;
49579 int res1 = 0 ;
49580 wxGBPosition temp2 ;
49581 wxGBSpan temp3 ;
49582 int val4 ;
49583 int ecode4 = 0 ;
49584 int val5 ;
49585 int ecode5 = 0 ;
49586 PyObject * obj0 = 0 ;
49587 PyObject * obj1 = 0 ;
49588 PyObject * obj2 = 0 ;
49589 PyObject * obj3 = 0 ;
49590 PyObject * obj4 = 0 ;
49591 PyObject * obj5 = 0 ;
49592 char * kwnames[] = {
49593 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49594 };
49595
49596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49597 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49598 if (!SWIG_IsOK(res1)) {
49599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49600 }
49601 {
49602 arg2 = &temp2;
49603 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49604 }
49605 {
49606 arg3 = &temp3;
49607 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49608 }
49609 ecode4 = SWIG_AsVal_int(obj3, &val4);
49610 if (!SWIG_IsOK(ecode4)) {
49611 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49612 }
49613 arg4 = static_cast< int >(val4);
49614 ecode5 = SWIG_AsVal_int(obj4, &val5);
49615 if (!SWIG_IsOK(ecode5)) {
49616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49617 }
49618 arg5 = static_cast< int >(val5);
49619 if (obj5) {
49620 arg6 = obj5;
49621 }
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49636 PyObject *resultobj = 0;
49637 int arg1 ;
49638 int arg2 ;
49639 wxGBPosition *arg3 = 0 ;
49640 wxGBSpan *arg4 = 0 ;
49641 int arg5 ;
49642 int arg6 ;
49643 PyObject *arg7 = (PyObject *) NULL ;
49644 wxGBSizerItem *result = 0 ;
49645 int val1 ;
49646 int ecode1 = 0 ;
49647 int val2 ;
49648 int ecode2 = 0 ;
49649 wxGBPosition temp3 ;
49650 wxGBSpan temp4 ;
49651 int val5 ;
49652 int ecode5 = 0 ;
49653 int val6 ;
49654 int ecode6 = 0 ;
49655 PyObject * obj0 = 0 ;
49656 PyObject * obj1 = 0 ;
49657 PyObject * obj2 = 0 ;
49658 PyObject * obj3 = 0 ;
49659 PyObject * obj4 = 0 ;
49660 PyObject * obj5 = 0 ;
49661 PyObject * obj6 = 0 ;
49662 char * kwnames[] = {
49663 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49664 };
49665
49666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49667 ecode1 = SWIG_AsVal_int(obj0, &val1);
49668 if (!SWIG_IsOK(ecode1)) {
49669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49670 }
49671 arg1 = static_cast< int >(val1);
49672 ecode2 = SWIG_AsVal_int(obj1, &val2);
49673 if (!SWIG_IsOK(ecode2)) {
49674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49675 }
49676 arg2 = static_cast< int >(val2);
49677 {
49678 arg3 = &temp3;
49679 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49680 }
49681 {
49682 arg4 = &temp4;
49683 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49684 }
49685 ecode5 = SWIG_AsVal_int(obj4, &val5);
49686 if (!SWIG_IsOK(ecode5)) {
49687 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49688 }
49689 arg5 = static_cast< int >(val5);
49690 ecode6 = SWIG_AsVal_int(obj5, &val6);
49691 if (!SWIG_IsOK(ecode6)) {
49692 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49693 }
49694 arg6 = static_cast< int >(val6);
49695 if (obj6) {
49696 arg7 = obj6;
49697 }
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49712 PyObject *resultobj = 0;
49713 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49714 wxGBPosition result;
49715 void *argp1 = 0 ;
49716 int res1 = 0 ;
49717 PyObject *swig_obj[1] ;
49718
49719 if (!args) SWIG_fail;
49720 swig_obj[0] = args;
49721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49722 if (!SWIG_IsOK(res1)) {
49723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49724 }
49725 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49726 {
49727 PyThreadState* __tstate = wxPyBeginAllowThreads();
49728 result = ((wxGBSizerItem const *)arg1)->GetPos();
49729 wxPyEndAllowThreads(__tstate);
49730 if (PyErr_Occurred()) SWIG_fail;
49731 }
49732 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49733 return resultobj;
49734 fail:
49735 return NULL;
49736 }
49737
49738
49739 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49740 PyObject *resultobj = 0;
49741 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49742 wxGBSpan result;
49743 void *argp1 = 0 ;
49744 int res1 = 0 ;
49745 PyObject *swig_obj[1] ;
49746
49747 if (!args) SWIG_fail;
49748 swig_obj[0] = args;
49749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49750 if (!SWIG_IsOK(res1)) {
49751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49752 }
49753 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49754 {
49755 PyThreadState* __tstate = wxPyBeginAllowThreads();
49756 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49757 wxPyEndAllowThreads(__tstate);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49768 PyObject *resultobj = 0;
49769 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49770 wxGBPosition *arg2 = 0 ;
49771 bool result;
49772 void *argp1 = 0 ;
49773 int res1 = 0 ;
49774 wxGBPosition temp2 ;
49775 PyObject * obj0 = 0 ;
49776 PyObject * obj1 = 0 ;
49777 char * kwnames[] = {
49778 (char *) "self",(char *) "pos", NULL
49779 };
49780
49781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49783 if (!SWIG_IsOK(res1)) {
49784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49785 }
49786 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49787 {
49788 arg2 = &temp2;
49789 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49790 }
49791 {
49792 PyThreadState* __tstate = wxPyBeginAllowThreads();
49793 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49794 wxPyEndAllowThreads(__tstate);
49795 if (PyErr_Occurred()) SWIG_fail;
49796 }
49797 {
49798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49799 }
49800 return resultobj;
49801 fail:
49802 return NULL;
49803 }
49804
49805
49806 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49807 PyObject *resultobj = 0;
49808 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49809 wxGBSpan *arg2 = 0 ;
49810 bool result;
49811 void *argp1 = 0 ;
49812 int res1 = 0 ;
49813 wxGBSpan temp2 ;
49814 PyObject * obj0 = 0 ;
49815 PyObject * obj1 = 0 ;
49816 char * kwnames[] = {
49817 (char *) "self",(char *) "span", NULL
49818 };
49819
49820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49822 if (!SWIG_IsOK(res1)) {
49823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49824 }
49825 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49826 {
49827 arg2 = &temp2;
49828 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49829 }
49830 {
49831 PyThreadState* __tstate = wxPyBeginAllowThreads();
49832 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49833 wxPyEndAllowThreads(__tstate);
49834 if (PyErr_Occurred()) SWIG_fail;
49835 }
49836 {
49837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49838 }
49839 return resultobj;
49840 fail:
49841 return NULL;
49842 }
49843
49844
49845 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49846 PyObject *resultobj = 0;
49847 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49848 wxGBSizerItem *arg2 = 0 ;
49849 bool result;
49850 void *argp1 = 0 ;
49851 int res1 = 0 ;
49852 void *argp2 = 0 ;
49853 int res2 = 0 ;
49854 PyObject * obj0 = 0 ;
49855 PyObject * obj1 = 0 ;
49856 char * kwnames[] = {
49857 (char *) "self",(char *) "other", NULL
49858 };
49859
49860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49862 if (!SWIG_IsOK(res1)) {
49863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49864 }
49865 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49867 if (!SWIG_IsOK(res2)) {
49868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49869 }
49870 if (!argp2) {
49871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49872 }
49873 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49874 {
49875 PyThreadState* __tstate = wxPyBeginAllowThreads();
49876 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49877 wxPyEndAllowThreads(__tstate);
49878 if (PyErr_Occurred()) SWIG_fail;
49879 }
49880 {
49881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49882 }
49883 return resultobj;
49884 fail:
49885 return NULL;
49886 }
49887
49888
49889 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49890 PyObject *resultobj = 0;
49891 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49892 wxGBPosition *arg2 = 0 ;
49893 wxGBSpan *arg3 = 0 ;
49894 bool result;
49895 void *argp1 = 0 ;
49896 int res1 = 0 ;
49897 wxGBPosition temp2 ;
49898 wxGBSpan temp3 ;
49899 PyObject * obj0 = 0 ;
49900 PyObject * obj1 = 0 ;
49901 PyObject * obj2 = 0 ;
49902 char * kwnames[] = {
49903 (char *) "self",(char *) "pos",(char *) "span", NULL
49904 };
49905
49906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49908 if (!SWIG_IsOK(res1)) {
49909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49910 }
49911 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49912 {
49913 arg2 = &temp2;
49914 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49915 }
49916 {
49917 arg3 = &temp3;
49918 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49919 }
49920 {
49921 PyThreadState* __tstate = wxPyBeginAllowThreads();
49922 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49923 wxPyEndAllowThreads(__tstate);
49924 if (PyErr_Occurred()) SWIG_fail;
49925 }
49926 {
49927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49928 }
49929 return resultobj;
49930 fail:
49931 return NULL;
49932 }
49933
49934
49935 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49936 PyObject *resultobj = 0;
49937 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49938 wxGBPosition result;
49939 void *argp1 = 0 ;
49940 int res1 = 0 ;
49941 PyObject *swig_obj[1] ;
49942
49943 if (!args) SWIG_fail;
49944 swig_obj[0] = args;
49945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49946 if (!SWIG_IsOK(res1)) {
49947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49948 }
49949 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 result = wxGBSizerItem_GetEndPos(arg1);
49953 wxPyEndAllowThreads(__tstate);
49954 if (PyErr_Occurred()) SWIG_fail;
49955 }
49956 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49957 return resultobj;
49958 fail:
49959 return NULL;
49960 }
49961
49962
49963 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49964 PyObject *resultobj = 0;
49965 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49966 wxGridBagSizer *result = 0 ;
49967 void *argp1 = 0 ;
49968 int res1 = 0 ;
49969 PyObject *swig_obj[1] ;
49970
49971 if (!args) SWIG_fail;
49972 swig_obj[0] = args;
49973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49974 if (!SWIG_IsOK(res1)) {
49975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49976 }
49977 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49978 {
49979 PyThreadState* __tstate = wxPyBeginAllowThreads();
49980 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49981 wxPyEndAllowThreads(__tstate);
49982 if (PyErr_Occurred()) SWIG_fail;
49983 }
49984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49985 return resultobj;
49986 fail:
49987 return NULL;
49988 }
49989
49990
49991 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49992 PyObject *resultobj = 0;
49993 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49994 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49995 void *argp1 = 0 ;
49996 int res1 = 0 ;
49997 void *argp2 = 0 ;
49998 int res2 = 0 ;
49999 PyObject * obj0 = 0 ;
50000 PyObject * obj1 = 0 ;
50001 char * kwnames[] = {
50002 (char *) "self",(char *) "sizer", NULL
50003 };
50004
50005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50007 if (!SWIG_IsOK(res1)) {
50008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50009 }
50010 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50011 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50012 if (!SWIG_IsOK(res2)) {
50013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50014 }
50015 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 (arg1)->SetGBSizer(arg2);
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_Py_Void();
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50030 PyObject *obj;
50031 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50032 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50033 return SWIG_Py_Void();
50034 }
50035
50036 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50037 return SWIG_Python_InitShadowInstance(args);
50038 }
50039
50040 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50041 PyObject *resultobj = 0;
50042 int arg1 = (int) 0 ;
50043 int arg2 = (int) 0 ;
50044 wxGridBagSizer *result = 0 ;
50045 int val1 ;
50046 int ecode1 = 0 ;
50047 int val2 ;
50048 int ecode2 = 0 ;
50049 PyObject * obj0 = 0 ;
50050 PyObject * obj1 = 0 ;
50051 char * kwnames[] = {
50052 (char *) "vgap",(char *) "hgap", NULL
50053 };
50054
50055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50056 if (obj0) {
50057 ecode1 = SWIG_AsVal_int(obj0, &val1);
50058 if (!SWIG_IsOK(ecode1)) {
50059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50060 }
50061 arg1 = static_cast< int >(val1);
50062 }
50063 if (obj1) {
50064 ecode2 = SWIG_AsVal_int(obj1, &val2);
50065 if (!SWIG_IsOK(ecode2)) {
50066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50067 }
50068 arg2 = static_cast< int >(val2);
50069 }
50070 {
50071 PyThreadState* __tstate = wxPyBeginAllowThreads();
50072 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50073 wxPyEndAllowThreads(__tstate);
50074 if (PyErr_Occurred()) SWIG_fail;
50075 }
50076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50084 PyObject *resultobj = 0;
50085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50086 PyObject *arg2 = (PyObject *) 0 ;
50087 wxGBPosition *arg3 = 0 ;
50088 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50089 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50090 int arg5 = (int) 0 ;
50091 int arg6 = (int) 0 ;
50092 PyObject *arg7 = (PyObject *) NULL ;
50093 wxGBSizerItem *result = 0 ;
50094 void *argp1 = 0 ;
50095 int res1 = 0 ;
50096 wxGBPosition temp3 ;
50097 wxGBSpan temp4 ;
50098 int val5 ;
50099 int ecode5 = 0 ;
50100 int val6 ;
50101 int ecode6 = 0 ;
50102 PyObject * obj0 = 0 ;
50103 PyObject * obj1 = 0 ;
50104 PyObject * obj2 = 0 ;
50105 PyObject * obj3 = 0 ;
50106 PyObject * obj4 = 0 ;
50107 PyObject * obj5 = 0 ;
50108 PyObject * obj6 = 0 ;
50109 char * kwnames[] = {
50110 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50111 };
50112
50113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50115 if (!SWIG_IsOK(res1)) {
50116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50117 }
50118 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50119 arg2 = obj1;
50120 {
50121 arg3 = &temp3;
50122 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50123 }
50124 if (obj3) {
50125 {
50126 arg4 = &temp4;
50127 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50128 }
50129 }
50130 if (obj4) {
50131 ecode5 = SWIG_AsVal_int(obj4, &val5);
50132 if (!SWIG_IsOK(ecode5)) {
50133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50134 }
50135 arg5 = static_cast< int >(val5);
50136 }
50137 if (obj5) {
50138 ecode6 = SWIG_AsVal_int(obj5, &val6);
50139 if (!SWIG_IsOK(ecode6)) {
50140 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50141 }
50142 arg6 = static_cast< int >(val6);
50143 }
50144 if (obj6) {
50145 arg7 = obj6;
50146 }
50147 {
50148 PyThreadState* __tstate = wxPyBeginAllowThreads();
50149 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50150 wxPyEndAllowThreads(__tstate);
50151 if (PyErr_Occurred()) SWIG_fail;
50152 }
50153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50154 return resultobj;
50155 fail:
50156 return NULL;
50157 }
50158
50159
50160 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50161 PyObject *resultobj = 0;
50162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50163 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50164 wxGBSizerItem *result = 0 ;
50165 void *argp1 = 0 ;
50166 int res1 = 0 ;
50167 int res2 = 0 ;
50168 PyObject * obj0 = 0 ;
50169 PyObject * obj1 = 0 ;
50170 char * kwnames[] = {
50171 (char *) "self",(char *) "item", NULL
50172 };
50173
50174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50176 if (!SWIG_IsOK(res1)) {
50177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50178 }
50179 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50180 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50181 if (!SWIG_IsOK(res2)) {
50182 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50183 }
50184 {
50185 PyThreadState* __tstate = wxPyBeginAllowThreads();
50186 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50187 wxPyEndAllowThreads(__tstate);
50188 if (PyErr_Occurred()) SWIG_fail;
50189 }
50190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50191 return resultobj;
50192 fail:
50193 return NULL;
50194 }
50195
50196
50197 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50198 PyObject *resultobj = 0;
50199 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50200 int arg2 ;
50201 int arg3 ;
50202 wxSize result;
50203 void *argp1 = 0 ;
50204 int res1 = 0 ;
50205 int val2 ;
50206 int ecode2 = 0 ;
50207 int val3 ;
50208 int ecode3 = 0 ;
50209 PyObject * obj0 = 0 ;
50210 PyObject * obj1 = 0 ;
50211 PyObject * obj2 = 0 ;
50212 char * kwnames[] = {
50213 (char *) "self",(char *) "row",(char *) "col", NULL
50214 };
50215
50216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50218 if (!SWIG_IsOK(res1)) {
50219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50220 }
50221 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50222 ecode2 = SWIG_AsVal_int(obj1, &val2);
50223 if (!SWIG_IsOK(ecode2)) {
50224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50225 }
50226 arg2 = static_cast< int >(val2);
50227 ecode3 = SWIG_AsVal_int(obj2, &val3);
50228 if (!SWIG_IsOK(ecode3)) {
50229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50230 }
50231 arg3 = static_cast< int >(val3);
50232 {
50233 PyThreadState* __tstate = wxPyBeginAllowThreads();
50234 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50235 wxPyEndAllowThreads(__tstate);
50236 if (PyErr_Occurred()) SWIG_fail;
50237 }
50238 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50239 return resultobj;
50240 fail:
50241 return NULL;
50242 }
50243
50244
50245 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50246 PyObject *resultobj = 0;
50247 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50248 wxSize result;
50249 void *argp1 = 0 ;
50250 int res1 = 0 ;
50251 PyObject *swig_obj[1] ;
50252
50253 if (!args) SWIG_fail;
50254 swig_obj[0] = args;
50255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50256 if (!SWIG_IsOK(res1)) {
50257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50258 }
50259 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50260 {
50261 PyThreadState* __tstate = wxPyBeginAllowThreads();
50262 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50263 wxPyEndAllowThreads(__tstate);
50264 if (PyErr_Occurred()) SWIG_fail;
50265 }
50266 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50267 return resultobj;
50268 fail:
50269 return NULL;
50270 }
50271
50272
50273 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50274 PyObject *resultobj = 0;
50275 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50276 wxSize *arg2 = 0 ;
50277 void *argp1 = 0 ;
50278 int res1 = 0 ;
50279 wxSize temp2 ;
50280 PyObject * obj0 = 0 ;
50281 PyObject * obj1 = 0 ;
50282 char * kwnames[] = {
50283 (char *) "self",(char *) "sz", NULL
50284 };
50285
50286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50288 if (!SWIG_IsOK(res1)) {
50289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50290 }
50291 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50292 {
50293 arg2 = &temp2;
50294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50295 }
50296 {
50297 PyThreadState* __tstate = wxPyBeginAllowThreads();
50298 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50299 wxPyEndAllowThreads(__tstate);
50300 if (PyErr_Occurred()) SWIG_fail;
50301 }
50302 resultobj = SWIG_Py_Void();
50303 return resultobj;
50304 fail:
50305 return NULL;
50306 }
50307
50308
50309 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50310 PyObject *resultobj = 0;
50311 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50312 wxWindow *arg2 = (wxWindow *) 0 ;
50313 wxGBPosition result;
50314 void *argp1 = 0 ;
50315 int res1 = 0 ;
50316 void *argp2 = 0 ;
50317 int res2 = 0 ;
50318
50319 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50321 if (!SWIG_IsOK(res1)) {
50322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50323 }
50324 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50325 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50326 if (!SWIG_IsOK(res2)) {
50327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50328 }
50329 arg2 = reinterpret_cast< wxWindow * >(argp2);
50330 {
50331 PyThreadState* __tstate = wxPyBeginAllowThreads();
50332 result = (arg1)->GetItemPosition(arg2);
50333 wxPyEndAllowThreads(__tstate);
50334 if (PyErr_Occurred()) SWIG_fail;
50335 }
50336 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50337 return resultobj;
50338 fail:
50339 return NULL;
50340 }
50341
50342
50343 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50344 PyObject *resultobj = 0;
50345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50346 wxSizer *arg2 = (wxSizer *) 0 ;
50347 wxGBPosition result;
50348 void *argp1 = 0 ;
50349 int res1 = 0 ;
50350 void *argp2 = 0 ;
50351 int res2 = 0 ;
50352
50353 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50355 if (!SWIG_IsOK(res1)) {
50356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50357 }
50358 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50359 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50360 if (!SWIG_IsOK(res2)) {
50361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50362 }
50363 arg2 = reinterpret_cast< wxSizer * >(argp2);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = (arg1)->GetItemPosition(arg2);
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50371 return resultobj;
50372 fail:
50373 return NULL;
50374 }
50375
50376
50377 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50378 PyObject *resultobj = 0;
50379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50380 size_t arg2 ;
50381 wxGBPosition result;
50382 void *argp1 = 0 ;
50383 int res1 = 0 ;
50384 size_t val2 ;
50385 int ecode2 = 0 ;
50386
50387 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50389 if (!SWIG_IsOK(res1)) {
50390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50391 }
50392 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50393 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50394 if (!SWIG_IsOK(ecode2)) {
50395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50396 }
50397 arg2 = static_cast< size_t >(val2);
50398 {
50399 PyThreadState* __tstate = wxPyBeginAllowThreads();
50400 result = (arg1)->GetItemPosition(arg2);
50401 wxPyEndAllowThreads(__tstate);
50402 if (PyErr_Occurred()) SWIG_fail;
50403 }
50404 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50412 int argc;
50413 PyObject *argv[3];
50414
50415 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50416 --argc;
50417 if (argc == 2) {
50418 int _v = 0;
50419 {
50420 void *vptr = 0;
50421 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50422 _v = SWIG_CheckState(res);
50423 }
50424 if (!_v) goto check_1;
50425 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50426 }
50427 check_1:
50428
50429 if (argc == 2) {
50430 int _v = 0;
50431 {
50432 void *vptr = 0;
50433 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50434 _v = SWIG_CheckState(res);
50435 }
50436 if (!_v) goto check_2;
50437 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50438 }
50439 check_2:
50440
50441 if (argc == 2) {
50442 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50443 }
50444
50445 fail:
50446 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50447 return NULL;
50448 }
50449
50450
50451 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50452 PyObject *resultobj = 0;
50453 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50454 wxWindow *arg2 = (wxWindow *) 0 ;
50455 wxGBPosition *arg3 = 0 ;
50456 bool result;
50457 void *argp1 = 0 ;
50458 int res1 = 0 ;
50459 void *argp2 = 0 ;
50460 int res2 = 0 ;
50461 wxGBPosition temp3 ;
50462
50463 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50465 if (!SWIG_IsOK(res1)) {
50466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50467 }
50468 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50470 if (!SWIG_IsOK(res2)) {
50471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50472 }
50473 arg2 = reinterpret_cast< wxWindow * >(argp2);
50474 {
50475 arg3 = &temp3;
50476 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50477 }
50478 {
50479 PyThreadState* __tstate = wxPyBeginAllowThreads();
50480 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50481 wxPyEndAllowThreads(__tstate);
50482 if (PyErr_Occurred()) SWIG_fail;
50483 }
50484 {
50485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50486 }
50487 return resultobj;
50488 fail:
50489 return NULL;
50490 }
50491
50492
50493 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50494 PyObject *resultobj = 0;
50495 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50496 wxSizer *arg2 = (wxSizer *) 0 ;
50497 wxGBPosition *arg3 = 0 ;
50498 bool result;
50499 void *argp1 = 0 ;
50500 int res1 = 0 ;
50501 void *argp2 = 0 ;
50502 int res2 = 0 ;
50503 wxGBPosition temp3 ;
50504
50505 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50507 if (!SWIG_IsOK(res1)) {
50508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50509 }
50510 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50511 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50512 if (!SWIG_IsOK(res2)) {
50513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50514 }
50515 arg2 = reinterpret_cast< wxSizer * >(argp2);
50516 {
50517 arg3 = &temp3;
50518 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50519 }
50520 {
50521 PyThreadState* __tstate = wxPyBeginAllowThreads();
50522 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50523 wxPyEndAllowThreads(__tstate);
50524 if (PyErr_Occurred()) SWIG_fail;
50525 }
50526 {
50527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50528 }
50529 return resultobj;
50530 fail:
50531 return NULL;
50532 }
50533
50534
50535 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50536 PyObject *resultobj = 0;
50537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50538 size_t arg2 ;
50539 wxGBPosition *arg3 = 0 ;
50540 bool result;
50541 void *argp1 = 0 ;
50542 int res1 = 0 ;
50543 size_t val2 ;
50544 int ecode2 = 0 ;
50545 wxGBPosition temp3 ;
50546
50547 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50549 if (!SWIG_IsOK(res1)) {
50550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50551 }
50552 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50553 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50554 if (!SWIG_IsOK(ecode2)) {
50555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50556 }
50557 arg2 = static_cast< size_t >(val2);
50558 {
50559 arg3 = &temp3;
50560 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50561 }
50562 {
50563 PyThreadState* __tstate = wxPyBeginAllowThreads();
50564 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50565 wxPyEndAllowThreads(__tstate);
50566 if (PyErr_Occurred()) SWIG_fail;
50567 }
50568 {
50569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50570 }
50571 return resultobj;
50572 fail:
50573 return NULL;
50574 }
50575
50576
50577 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50578 int argc;
50579 PyObject *argv[4];
50580
50581 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50582 --argc;
50583 if (argc == 3) {
50584 int _v = 0;
50585 {
50586 void *vptr = 0;
50587 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50588 _v = SWIG_CheckState(res);
50589 }
50590 if (!_v) goto check_1;
50591 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50592 }
50593 check_1:
50594
50595 if (argc == 3) {
50596 int _v = 0;
50597 {
50598 void *vptr = 0;
50599 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50600 _v = SWIG_CheckState(res);
50601 }
50602 if (!_v) goto check_2;
50603 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50604 }
50605 check_2:
50606
50607 if (argc == 3) {
50608 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50609 }
50610
50611 fail:
50612 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50618 PyObject *resultobj = 0;
50619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50620 wxWindow *arg2 = (wxWindow *) 0 ;
50621 wxGBSpan result;
50622 void *argp1 = 0 ;
50623 int res1 = 0 ;
50624 void *argp2 = 0 ;
50625 int res2 = 0 ;
50626
50627 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50629 if (!SWIG_IsOK(res1)) {
50630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50631 }
50632 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50633 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50634 if (!SWIG_IsOK(res2)) {
50635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50636 }
50637 arg2 = reinterpret_cast< wxWindow * >(argp2);
50638 {
50639 PyThreadState* __tstate = wxPyBeginAllowThreads();
50640 result = (arg1)->GetItemSpan(arg2);
50641 wxPyEndAllowThreads(__tstate);
50642 if (PyErr_Occurred()) SWIG_fail;
50643 }
50644 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50645 return resultobj;
50646 fail:
50647 return NULL;
50648 }
50649
50650
50651 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50652 PyObject *resultobj = 0;
50653 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50654 wxSizer *arg2 = (wxSizer *) 0 ;
50655 wxGBSpan result;
50656 void *argp1 = 0 ;
50657 int res1 = 0 ;
50658 void *argp2 = 0 ;
50659 int res2 = 0 ;
50660
50661 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50663 if (!SWIG_IsOK(res1)) {
50664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50665 }
50666 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50667 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50668 if (!SWIG_IsOK(res2)) {
50669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50670 }
50671 arg2 = reinterpret_cast< wxSizer * >(argp2);
50672 {
50673 PyThreadState* __tstate = wxPyBeginAllowThreads();
50674 result = (arg1)->GetItemSpan(arg2);
50675 wxPyEndAllowThreads(__tstate);
50676 if (PyErr_Occurred()) SWIG_fail;
50677 }
50678 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50679 return resultobj;
50680 fail:
50681 return NULL;
50682 }
50683
50684
50685 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50686 PyObject *resultobj = 0;
50687 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50688 size_t arg2 ;
50689 wxGBSpan result;
50690 void *argp1 = 0 ;
50691 int res1 = 0 ;
50692 size_t val2 ;
50693 int ecode2 = 0 ;
50694
50695 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50697 if (!SWIG_IsOK(res1)) {
50698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50699 }
50700 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50701 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50702 if (!SWIG_IsOK(ecode2)) {
50703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50704 }
50705 arg2 = static_cast< size_t >(val2);
50706 {
50707 PyThreadState* __tstate = wxPyBeginAllowThreads();
50708 result = (arg1)->GetItemSpan(arg2);
50709 wxPyEndAllowThreads(__tstate);
50710 if (PyErr_Occurred()) SWIG_fail;
50711 }
50712 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50713 return resultobj;
50714 fail:
50715 return NULL;
50716 }
50717
50718
50719 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50720 int argc;
50721 PyObject *argv[3];
50722
50723 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50724 --argc;
50725 if (argc == 2) {
50726 int _v = 0;
50727 {
50728 void *vptr = 0;
50729 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50730 _v = SWIG_CheckState(res);
50731 }
50732 if (!_v) goto check_1;
50733 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50734 }
50735 check_1:
50736
50737 if (argc == 2) {
50738 int _v = 0;
50739 {
50740 void *vptr = 0;
50741 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50742 _v = SWIG_CheckState(res);
50743 }
50744 if (!_v) goto check_2;
50745 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50746 }
50747 check_2:
50748
50749 if (argc == 2) {
50750 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50751 }
50752
50753 fail:
50754 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50755 return NULL;
50756 }
50757
50758
50759 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50760 PyObject *resultobj = 0;
50761 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50762 wxWindow *arg2 = (wxWindow *) 0 ;
50763 wxGBSpan *arg3 = 0 ;
50764 bool result;
50765 void *argp1 = 0 ;
50766 int res1 = 0 ;
50767 void *argp2 = 0 ;
50768 int res2 = 0 ;
50769 wxGBSpan temp3 ;
50770
50771 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res1)) {
50774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50775 }
50776 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50777 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50778 if (!SWIG_IsOK(res2)) {
50779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50780 }
50781 arg2 = reinterpret_cast< wxWindow * >(argp2);
50782 {
50783 arg3 = &temp3;
50784 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50785 }
50786 {
50787 PyThreadState* __tstate = wxPyBeginAllowThreads();
50788 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50789 wxPyEndAllowThreads(__tstate);
50790 if (PyErr_Occurred()) SWIG_fail;
50791 }
50792 {
50793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50794 }
50795 return resultobj;
50796 fail:
50797 return NULL;
50798 }
50799
50800
50801 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50802 PyObject *resultobj = 0;
50803 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50804 wxSizer *arg2 = (wxSizer *) 0 ;
50805 wxGBSpan *arg3 = 0 ;
50806 bool result;
50807 void *argp1 = 0 ;
50808 int res1 = 0 ;
50809 void *argp2 = 0 ;
50810 int res2 = 0 ;
50811 wxGBSpan temp3 ;
50812
50813 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50815 if (!SWIG_IsOK(res1)) {
50816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50817 }
50818 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50819 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50820 if (!SWIG_IsOK(res2)) {
50821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50822 }
50823 arg2 = reinterpret_cast< wxSizer * >(argp2);
50824 {
50825 arg3 = &temp3;
50826 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50827 }
50828 {
50829 PyThreadState* __tstate = wxPyBeginAllowThreads();
50830 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50831 wxPyEndAllowThreads(__tstate);
50832 if (PyErr_Occurred()) SWIG_fail;
50833 }
50834 {
50835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50836 }
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50844 PyObject *resultobj = 0;
50845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50846 size_t arg2 ;
50847 wxGBSpan *arg3 = 0 ;
50848 bool result;
50849 void *argp1 = 0 ;
50850 int res1 = 0 ;
50851 size_t val2 ;
50852 int ecode2 = 0 ;
50853 wxGBSpan temp3 ;
50854
50855 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50857 if (!SWIG_IsOK(res1)) {
50858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50859 }
50860 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50861 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50862 if (!SWIG_IsOK(ecode2)) {
50863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50864 }
50865 arg2 = static_cast< size_t >(val2);
50866 {
50867 arg3 = &temp3;
50868 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50869 }
50870 {
50871 PyThreadState* __tstate = wxPyBeginAllowThreads();
50872 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50873 wxPyEndAllowThreads(__tstate);
50874 if (PyErr_Occurred()) SWIG_fail;
50875 }
50876 {
50877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50878 }
50879 return resultobj;
50880 fail:
50881 return NULL;
50882 }
50883
50884
50885 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50886 int argc;
50887 PyObject *argv[4];
50888
50889 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50890 --argc;
50891 if (argc == 3) {
50892 int _v = 0;
50893 {
50894 void *vptr = 0;
50895 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50896 _v = SWIG_CheckState(res);
50897 }
50898 if (!_v) goto check_1;
50899 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50900 }
50901 check_1:
50902
50903 if (argc == 3) {
50904 int _v = 0;
50905 {
50906 void *vptr = 0;
50907 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50908 _v = SWIG_CheckState(res);
50909 }
50910 if (!_v) goto check_2;
50911 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50912 }
50913 check_2:
50914
50915 if (argc == 3) {
50916 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50917 }
50918
50919 fail:
50920 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50921 return NULL;
50922 }
50923
50924
50925 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50926 PyObject *resultobj = 0;
50927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50928 wxWindow *arg2 = (wxWindow *) 0 ;
50929 wxGBSizerItem *result = 0 ;
50930 void *argp1 = 0 ;
50931 int res1 = 0 ;
50932 void *argp2 = 0 ;
50933 int res2 = 0 ;
50934
50935 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50937 if (!SWIG_IsOK(res1)) {
50938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50939 }
50940 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50941 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50942 if (!SWIG_IsOK(res2)) {
50943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50944 }
50945 arg2 = reinterpret_cast< wxWindow * >(argp2);
50946 {
50947 PyThreadState* __tstate = wxPyBeginAllowThreads();
50948 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50949 wxPyEndAllowThreads(__tstate);
50950 if (PyErr_Occurred()) SWIG_fail;
50951 }
50952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50953 return resultobj;
50954 fail:
50955 return NULL;
50956 }
50957
50958
50959 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50960 PyObject *resultobj = 0;
50961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50962 wxSizer *arg2 = (wxSizer *) 0 ;
50963 wxGBSizerItem *result = 0 ;
50964 void *argp1 = 0 ;
50965 int res1 = 0 ;
50966 void *argp2 = 0 ;
50967 int res2 = 0 ;
50968
50969 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50971 if (!SWIG_IsOK(res1)) {
50972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50973 }
50974 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50975 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50976 if (!SWIG_IsOK(res2)) {
50977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50978 }
50979 arg2 = reinterpret_cast< wxSizer * >(argp2);
50980 {
50981 PyThreadState* __tstate = wxPyBeginAllowThreads();
50982 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50983 wxPyEndAllowThreads(__tstate);
50984 if (PyErr_Occurred()) SWIG_fail;
50985 }
50986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50987 return resultobj;
50988 fail:
50989 return NULL;
50990 }
50991
50992
50993 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50994 int argc;
50995 PyObject *argv[3];
50996
50997 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50998 --argc;
50999 if (argc == 2) {
51000 int _v = 0;
51001 {
51002 void *vptr = 0;
51003 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51004 _v = SWIG_CheckState(res);
51005 }
51006 if (!_v) goto check_1;
51007 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51008 }
51009 check_1:
51010
51011 if (argc == 2) {
51012 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51013 }
51014
51015 fail:
51016 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51017 return NULL;
51018 }
51019
51020
51021 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51022 PyObject *resultobj = 0;
51023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51024 wxGBPosition *arg2 = 0 ;
51025 wxGBSizerItem *result = 0 ;
51026 void *argp1 = 0 ;
51027 int res1 = 0 ;
51028 wxGBPosition temp2 ;
51029 PyObject * obj0 = 0 ;
51030 PyObject * obj1 = 0 ;
51031 char * kwnames[] = {
51032 (char *) "self",(char *) "pos", NULL
51033 };
51034
51035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51037 if (!SWIG_IsOK(res1)) {
51038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51039 }
51040 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51041 {
51042 arg2 = &temp2;
51043 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51044 }
51045 {
51046 PyThreadState* __tstate = wxPyBeginAllowThreads();
51047 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51048 wxPyEndAllowThreads(__tstate);
51049 if (PyErr_Occurred()) SWIG_fail;
51050 }
51051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51052 return resultobj;
51053 fail:
51054 return NULL;
51055 }
51056
51057
51058 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51059 PyObject *resultobj = 0;
51060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51061 wxPoint *arg2 = 0 ;
51062 wxGBSizerItem *result = 0 ;
51063 void *argp1 = 0 ;
51064 int res1 = 0 ;
51065 wxPoint temp2 ;
51066 PyObject * obj0 = 0 ;
51067 PyObject * obj1 = 0 ;
51068 char * kwnames[] = {
51069 (char *) "self",(char *) "pt", NULL
51070 };
51071
51072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51076 }
51077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51078 {
51079 arg2 = &temp2;
51080 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51081 }
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51096 PyObject *resultobj = 0;
51097 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51098 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51099 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51100 bool result;
51101 void *argp1 = 0 ;
51102 int res1 = 0 ;
51103 void *argp2 = 0 ;
51104 int res2 = 0 ;
51105 void *argp3 = 0 ;
51106 int res3 = 0 ;
51107 PyObject * obj0 = 0 ;
51108 PyObject * obj1 = 0 ;
51109 PyObject * obj2 = 0 ;
51110 char * kwnames[] = {
51111 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51112 };
51113
51114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51116 if (!SWIG_IsOK(res1)) {
51117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51118 }
51119 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51121 if (!SWIG_IsOK(res2)) {
51122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51123 }
51124 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51125 if (obj2) {
51126 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51127 if (!SWIG_IsOK(res3)) {
51128 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51129 }
51130 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51131 }
51132 {
51133 PyThreadState* __tstate = wxPyBeginAllowThreads();
51134 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51135 wxPyEndAllowThreads(__tstate);
51136 if (PyErr_Occurred()) SWIG_fail;
51137 }
51138 {
51139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51140 }
51141 return resultobj;
51142 fail:
51143 return NULL;
51144 }
51145
51146
51147 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51148 PyObject *resultobj = 0;
51149 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51150 wxGBPosition *arg2 = 0 ;
51151 wxGBSpan *arg3 = 0 ;
51152 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51153 bool result;
51154 void *argp1 = 0 ;
51155 int res1 = 0 ;
51156 wxGBPosition temp2 ;
51157 wxGBSpan temp3 ;
51158 void *argp4 = 0 ;
51159 int res4 = 0 ;
51160 PyObject * obj0 = 0 ;
51161 PyObject * obj1 = 0 ;
51162 PyObject * obj2 = 0 ;
51163 PyObject * obj3 = 0 ;
51164 char * kwnames[] = {
51165 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51166 };
51167
51168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51170 if (!SWIG_IsOK(res1)) {
51171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51172 }
51173 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51174 {
51175 arg2 = &temp2;
51176 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51177 }
51178 {
51179 arg3 = &temp3;
51180 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51181 }
51182 if (obj3) {
51183 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51184 if (!SWIG_IsOK(res4)) {
51185 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51186 }
51187 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51188 }
51189 {
51190 PyThreadState* __tstate = wxPyBeginAllowThreads();
51191 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51192 wxPyEndAllowThreads(__tstate);
51193 if (PyErr_Occurred()) SWIG_fail;
51194 }
51195 {
51196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51197 }
51198 return resultobj;
51199 fail:
51200 return NULL;
51201 }
51202
51203
51204 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51205 PyObject *obj;
51206 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51207 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51208 return SWIG_Py_Void();
51209 }
51210
51211 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51212 return SWIG_Python_InitShadowInstance(args);
51213 }
51214
51215 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51216 PyObject *resultobj = 0;
51217 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51218 wxRelationship arg2 ;
51219 wxWindow *arg3 = (wxWindow *) 0 ;
51220 wxEdge arg4 ;
51221 int arg5 = (int) 0 ;
51222 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51223 void *argp1 = 0 ;
51224 int res1 = 0 ;
51225 int val2 ;
51226 int ecode2 = 0 ;
51227 void *argp3 = 0 ;
51228 int res3 = 0 ;
51229 int val4 ;
51230 int ecode4 = 0 ;
51231 int val5 ;
51232 int ecode5 = 0 ;
51233 int val6 ;
51234 int ecode6 = 0 ;
51235 PyObject * obj0 = 0 ;
51236 PyObject * obj1 = 0 ;
51237 PyObject * obj2 = 0 ;
51238 PyObject * obj3 = 0 ;
51239 PyObject * obj4 = 0 ;
51240 PyObject * obj5 = 0 ;
51241 char * kwnames[] = {
51242 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51243 };
51244
51245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51247 if (!SWIG_IsOK(res1)) {
51248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51249 }
51250 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51251 ecode2 = SWIG_AsVal_int(obj1, &val2);
51252 if (!SWIG_IsOK(ecode2)) {
51253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51254 }
51255 arg2 = static_cast< wxRelationship >(val2);
51256 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51257 if (!SWIG_IsOK(res3)) {
51258 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51259 }
51260 arg3 = reinterpret_cast< wxWindow * >(argp3);
51261 ecode4 = SWIG_AsVal_int(obj3, &val4);
51262 if (!SWIG_IsOK(ecode4)) {
51263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51264 }
51265 arg4 = static_cast< wxEdge >(val4);
51266 if (obj4) {
51267 ecode5 = SWIG_AsVal_int(obj4, &val5);
51268 if (!SWIG_IsOK(ecode5)) {
51269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51270 }
51271 arg5 = static_cast< int >(val5);
51272 }
51273 if (obj5) {
51274 ecode6 = SWIG_AsVal_int(obj5, &val6);
51275 if (!SWIG_IsOK(ecode6)) {
51276 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51277 }
51278 arg6 = static_cast< int >(val6);
51279 }
51280 {
51281 PyThreadState* __tstate = wxPyBeginAllowThreads();
51282 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51283 wxPyEndAllowThreads(__tstate);
51284 if (PyErr_Occurred()) SWIG_fail;
51285 }
51286 resultobj = SWIG_Py_Void();
51287 return resultobj;
51288 fail:
51289 return NULL;
51290 }
51291
51292
51293 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51294 PyObject *resultobj = 0;
51295 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51296 wxWindow *arg2 = (wxWindow *) 0 ;
51297 int arg3 = (int) 0 ;
51298 void *argp1 = 0 ;
51299 int res1 = 0 ;
51300 void *argp2 = 0 ;
51301 int res2 = 0 ;
51302 int val3 ;
51303 int ecode3 = 0 ;
51304 PyObject * obj0 = 0 ;
51305 PyObject * obj1 = 0 ;
51306 PyObject * obj2 = 0 ;
51307 char * kwnames[] = {
51308 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51309 };
51310
51311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51313 if (!SWIG_IsOK(res1)) {
51314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51315 }
51316 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51317 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51318 if (!SWIG_IsOK(res2)) {
51319 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51320 }
51321 arg2 = reinterpret_cast< wxWindow * >(argp2);
51322 if (obj2) {
51323 ecode3 = SWIG_AsVal_int(obj2, &val3);
51324 if (!SWIG_IsOK(ecode3)) {
51325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51326 }
51327 arg3 = static_cast< int >(val3);
51328 }
51329 {
51330 PyThreadState* __tstate = wxPyBeginAllowThreads();
51331 (arg1)->LeftOf(arg2,arg3);
51332 wxPyEndAllowThreads(__tstate);
51333 if (PyErr_Occurred()) SWIG_fail;
51334 }
51335 resultobj = SWIG_Py_Void();
51336 return resultobj;
51337 fail:
51338 return NULL;
51339 }
51340
51341
51342 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51343 PyObject *resultobj = 0;
51344 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51345 wxWindow *arg2 = (wxWindow *) 0 ;
51346 int arg3 = (int) 0 ;
51347 void *argp1 = 0 ;
51348 int res1 = 0 ;
51349 void *argp2 = 0 ;
51350 int res2 = 0 ;
51351 int val3 ;
51352 int ecode3 = 0 ;
51353 PyObject * obj0 = 0 ;
51354 PyObject * obj1 = 0 ;
51355 PyObject * obj2 = 0 ;
51356 char * kwnames[] = {
51357 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51358 };
51359
51360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51362 if (!SWIG_IsOK(res1)) {
51363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51364 }
51365 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51367 if (!SWIG_IsOK(res2)) {
51368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51369 }
51370 arg2 = reinterpret_cast< wxWindow * >(argp2);
51371 if (obj2) {
51372 ecode3 = SWIG_AsVal_int(obj2, &val3);
51373 if (!SWIG_IsOK(ecode3)) {
51374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51375 }
51376 arg3 = static_cast< int >(val3);
51377 }
51378 {
51379 PyThreadState* __tstate = wxPyBeginAllowThreads();
51380 (arg1)->RightOf(arg2,arg3);
51381 wxPyEndAllowThreads(__tstate);
51382 if (PyErr_Occurred()) SWIG_fail;
51383 }
51384 resultobj = SWIG_Py_Void();
51385 return resultobj;
51386 fail:
51387 return NULL;
51388 }
51389
51390
51391 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51392 PyObject *resultobj = 0;
51393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51394 wxWindow *arg2 = (wxWindow *) 0 ;
51395 int arg3 = (int) 0 ;
51396 void *argp1 = 0 ;
51397 int res1 = 0 ;
51398 void *argp2 = 0 ;
51399 int res2 = 0 ;
51400 int val3 ;
51401 int ecode3 = 0 ;
51402 PyObject * obj0 = 0 ;
51403 PyObject * obj1 = 0 ;
51404 PyObject * obj2 = 0 ;
51405 char * kwnames[] = {
51406 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51407 };
51408
51409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51411 if (!SWIG_IsOK(res1)) {
51412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51413 }
51414 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51416 if (!SWIG_IsOK(res2)) {
51417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51418 }
51419 arg2 = reinterpret_cast< wxWindow * >(argp2);
51420 if (obj2) {
51421 ecode3 = SWIG_AsVal_int(obj2, &val3);
51422 if (!SWIG_IsOK(ecode3)) {
51423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51424 }
51425 arg3 = static_cast< int >(val3);
51426 }
51427 {
51428 PyThreadState* __tstate = wxPyBeginAllowThreads();
51429 (arg1)->Above(arg2,arg3);
51430 wxPyEndAllowThreads(__tstate);
51431 if (PyErr_Occurred()) SWIG_fail;
51432 }
51433 resultobj = SWIG_Py_Void();
51434 return resultobj;
51435 fail:
51436 return NULL;
51437 }
51438
51439
51440 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51441 PyObject *resultobj = 0;
51442 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51443 wxWindow *arg2 = (wxWindow *) 0 ;
51444 int arg3 = (int) 0 ;
51445 void *argp1 = 0 ;
51446 int res1 = 0 ;
51447 void *argp2 = 0 ;
51448 int res2 = 0 ;
51449 int val3 ;
51450 int ecode3 = 0 ;
51451 PyObject * obj0 = 0 ;
51452 PyObject * obj1 = 0 ;
51453 PyObject * obj2 = 0 ;
51454 char * kwnames[] = {
51455 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51456 };
51457
51458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51460 if (!SWIG_IsOK(res1)) {
51461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51462 }
51463 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51465 if (!SWIG_IsOK(res2)) {
51466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51467 }
51468 arg2 = reinterpret_cast< wxWindow * >(argp2);
51469 if (obj2) {
51470 ecode3 = SWIG_AsVal_int(obj2, &val3);
51471 if (!SWIG_IsOK(ecode3)) {
51472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51473 }
51474 arg3 = static_cast< int >(val3);
51475 }
51476 {
51477 PyThreadState* __tstate = wxPyBeginAllowThreads();
51478 (arg1)->Below(arg2,arg3);
51479 wxPyEndAllowThreads(__tstate);
51480 if (PyErr_Occurred()) SWIG_fail;
51481 }
51482 resultobj = SWIG_Py_Void();
51483 return resultobj;
51484 fail:
51485 return NULL;
51486 }
51487
51488
51489 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51490 PyObject *resultobj = 0;
51491 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51492 wxWindow *arg2 = (wxWindow *) 0 ;
51493 wxEdge arg3 ;
51494 int arg4 = (int) 0 ;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 void *argp2 = 0 ;
51498 int res2 = 0 ;
51499 int val3 ;
51500 int ecode3 = 0 ;
51501 int val4 ;
51502 int ecode4 = 0 ;
51503 PyObject * obj0 = 0 ;
51504 PyObject * obj1 = 0 ;
51505 PyObject * obj2 = 0 ;
51506 PyObject * obj3 = 0 ;
51507 char * kwnames[] = {
51508 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51509 };
51510
51511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51513 if (!SWIG_IsOK(res1)) {
51514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51515 }
51516 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51517 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51518 if (!SWIG_IsOK(res2)) {
51519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51520 }
51521 arg2 = reinterpret_cast< wxWindow * >(argp2);
51522 ecode3 = SWIG_AsVal_int(obj2, &val3);
51523 if (!SWIG_IsOK(ecode3)) {
51524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51525 }
51526 arg3 = static_cast< wxEdge >(val3);
51527 if (obj3) {
51528 ecode4 = SWIG_AsVal_int(obj3, &val4);
51529 if (!SWIG_IsOK(ecode4)) {
51530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51531 }
51532 arg4 = static_cast< int >(val4);
51533 }
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 (arg1)->SameAs(arg2,arg3,arg4);
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_Py_Void();
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51548 PyObject *resultobj = 0;
51549 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51550 wxWindow *arg2 = (wxWindow *) 0 ;
51551 wxEdge arg3 ;
51552 int arg4 ;
51553 void *argp1 = 0 ;
51554 int res1 = 0 ;
51555 void *argp2 = 0 ;
51556 int res2 = 0 ;
51557 int val3 ;
51558 int ecode3 = 0 ;
51559 int val4 ;
51560 int ecode4 = 0 ;
51561 PyObject * obj0 = 0 ;
51562 PyObject * obj1 = 0 ;
51563 PyObject * obj2 = 0 ;
51564 PyObject * obj3 = 0 ;
51565 char * kwnames[] = {
51566 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51567 };
51568
51569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51571 if (!SWIG_IsOK(res1)) {
51572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51573 }
51574 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51576 if (!SWIG_IsOK(res2)) {
51577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51578 }
51579 arg2 = reinterpret_cast< wxWindow * >(argp2);
51580 ecode3 = SWIG_AsVal_int(obj2, &val3);
51581 if (!SWIG_IsOK(ecode3)) {
51582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51583 }
51584 arg3 = static_cast< wxEdge >(val3);
51585 ecode4 = SWIG_AsVal_int(obj3, &val4);
51586 if (!SWIG_IsOK(ecode4)) {
51587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51588 }
51589 arg4 = static_cast< int >(val4);
51590 {
51591 PyThreadState* __tstate = wxPyBeginAllowThreads();
51592 (arg1)->PercentOf(arg2,arg3,arg4);
51593 wxPyEndAllowThreads(__tstate);
51594 if (PyErr_Occurred()) SWIG_fail;
51595 }
51596 resultobj = SWIG_Py_Void();
51597 return resultobj;
51598 fail:
51599 return NULL;
51600 }
51601
51602
51603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51604 PyObject *resultobj = 0;
51605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51606 int arg2 ;
51607 void *argp1 = 0 ;
51608 int res1 = 0 ;
51609 int val2 ;
51610 int ecode2 = 0 ;
51611 PyObject * obj0 = 0 ;
51612 PyObject * obj1 = 0 ;
51613 char * kwnames[] = {
51614 (char *) "self",(char *) "val", NULL
51615 };
51616
51617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51619 if (!SWIG_IsOK(res1)) {
51620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51621 }
51622 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51623 ecode2 = SWIG_AsVal_int(obj1, &val2);
51624 if (!SWIG_IsOK(ecode2)) {
51625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51626 }
51627 arg2 = static_cast< int >(val2);
51628 {
51629 PyThreadState* __tstate = wxPyBeginAllowThreads();
51630 (arg1)->Absolute(arg2);
51631 wxPyEndAllowThreads(__tstate);
51632 if (PyErr_Occurred()) SWIG_fail;
51633 }
51634 resultobj = SWIG_Py_Void();
51635 return resultobj;
51636 fail:
51637 return NULL;
51638 }
51639
51640
51641 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51642 PyObject *resultobj = 0;
51643 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51644 void *argp1 = 0 ;
51645 int res1 = 0 ;
51646 PyObject *swig_obj[1] ;
51647
51648 if (!args) SWIG_fail;
51649 swig_obj[0] = args;
51650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51651 if (!SWIG_IsOK(res1)) {
51652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51653 }
51654 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51655 {
51656 PyThreadState* __tstate = wxPyBeginAllowThreads();
51657 (arg1)->Unconstrained();
51658 wxPyEndAllowThreads(__tstate);
51659 if (PyErr_Occurred()) SWIG_fail;
51660 }
51661 resultobj = SWIG_Py_Void();
51662 return resultobj;
51663 fail:
51664 return NULL;
51665 }
51666
51667
51668 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51669 PyObject *resultobj = 0;
51670 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51671 void *argp1 = 0 ;
51672 int res1 = 0 ;
51673 PyObject *swig_obj[1] ;
51674
51675 if (!args) SWIG_fail;
51676 swig_obj[0] = args;
51677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51678 if (!SWIG_IsOK(res1)) {
51679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51680 }
51681 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51682 {
51683 PyThreadState* __tstate = wxPyBeginAllowThreads();
51684 (arg1)->AsIs();
51685 wxPyEndAllowThreads(__tstate);
51686 if (PyErr_Occurred()) SWIG_fail;
51687 }
51688 resultobj = SWIG_Py_Void();
51689 return resultobj;
51690 fail:
51691 return NULL;
51692 }
51693
51694
51695 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51696 PyObject *resultobj = 0;
51697 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51698 wxWindow *result = 0 ;
51699 void *argp1 = 0 ;
51700 int res1 = 0 ;
51701 PyObject *swig_obj[1] ;
51702
51703 if (!args) SWIG_fail;
51704 swig_obj[0] = args;
51705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51706 if (!SWIG_IsOK(res1)) {
51707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51708 }
51709 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51710 {
51711 PyThreadState* __tstate = wxPyBeginAllowThreads();
51712 result = (wxWindow *)(arg1)->GetOtherWindow();
51713 wxPyEndAllowThreads(__tstate);
51714 if (PyErr_Occurred()) SWIG_fail;
51715 }
51716 {
51717 resultobj = wxPyMake_wxObject(result, 0);
51718 }
51719 return resultobj;
51720 fail:
51721 return NULL;
51722 }
51723
51724
51725 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51726 PyObject *resultobj = 0;
51727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51728 wxEdge result;
51729 void *argp1 = 0 ;
51730 int res1 = 0 ;
51731 PyObject *swig_obj[1] ;
51732
51733 if (!args) SWIG_fail;
51734 swig_obj[0] = args;
51735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51736 if (!SWIG_IsOK(res1)) {
51737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51738 }
51739 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51740 {
51741 PyThreadState* __tstate = wxPyBeginAllowThreads();
51742 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51743 wxPyEndAllowThreads(__tstate);
51744 if (PyErr_Occurred()) SWIG_fail;
51745 }
51746 resultobj = SWIG_From_int(static_cast< int >(result));
51747 return resultobj;
51748 fail:
51749 return NULL;
51750 }
51751
51752
51753 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51754 PyObject *resultobj = 0;
51755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51756 wxEdge arg2 ;
51757 void *argp1 = 0 ;
51758 int res1 = 0 ;
51759 int val2 ;
51760 int ecode2 = 0 ;
51761 PyObject * obj0 = 0 ;
51762 PyObject * obj1 = 0 ;
51763 char * kwnames[] = {
51764 (char *) "self",(char *) "which", NULL
51765 };
51766
51767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51769 if (!SWIG_IsOK(res1)) {
51770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51771 }
51772 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51773 ecode2 = SWIG_AsVal_int(obj1, &val2);
51774 if (!SWIG_IsOK(ecode2)) {
51775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51776 }
51777 arg2 = static_cast< wxEdge >(val2);
51778 {
51779 PyThreadState* __tstate = wxPyBeginAllowThreads();
51780 (arg1)->SetEdge(arg2);
51781 wxPyEndAllowThreads(__tstate);
51782 if (PyErr_Occurred()) SWIG_fail;
51783 }
51784 resultobj = SWIG_Py_Void();
51785 return resultobj;
51786 fail:
51787 return NULL;
51788 }
51789
51790
51791 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51792 PyObject *resultobj = 0;
51793 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51794 int arg2 ;
51795 void *argp1 = 0 ;
51796 int res1 = 0 ;
51797 int val2 ;
51798 int ecode2 = 0 ;
51799 PyObject * obj0 = 0 ;
51800 PyObject * obj1 = 0 ;
51801 char * kwnames[] = {
51802 (char *) "self",(char *) "v", NULL
51803 };
51804
51805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51807 if (!SWIG_IsOK(res1)) {
51808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51809 }
51810 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51811 ecode2 = SWIG_AsVal_int(obj1, &val2);
51812 if (!SWIG_IsOK(ecode2)) {
51813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51814 }
51815 arg2 = static_cast< int >(val2);
51816 {
51817 PyThreadState* __tstate = wxPyBeginAllowThreads();
51818 (arg1)->SetValue(arg2);
51819 wxPyEndAllowThreads(__tstate);
51820 if (PyErr_Occurred()) SWIG_fail;
51821 }
51822 resultobj = SWIG_Py_Void();
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51830 PyObject *resultobj = 0;
51831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51832 int result;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 PyObject *swig_obj[1] ;
51836
51837 if (!args) SWIG_fail;
51838 swig_obj[0] = args;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51842 }
51843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51844 {
51845 PyThreadState* __tstate = wxPyBeginAllowThreads();
51846 result = (int)(arg1)->GetMargin();
51847 wxPyEndAllowThreads(__tstate);
51848 if (PyErr_Occurred()) SWIG_fail;
51849 }
51850 resultobj = SWIG_From_int(static_cast< int >(result));
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51858 PyObject *resultobj = 0;
51859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51860 int arg2 ;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 int val2 ;
51864 int ecode2 = 0 ;
51865 PyObject * obj0 = 0 ;
51866 PyObject * obj1 = 0 ;
51867 char * kwnames[] = {
51868 (char *) "self",(char *) "m", NULL
51869 };
51870
51871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51873 if (!SWIG_IsOK(res1)) {
51874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51875 }
51876 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51877 ecode2 = SWIG_AsVal_int(obj1, &val2);
51878 if (!SWIG_IsOK(ecode2)) {
51879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51880 }
51881 arg2 = static_cast< int >(val2);
51882 {
51883 PyThreadState* __tstate = wxPyBeginAllowThreads();
51884 (arg1)->SetMargin(arg2);
51885 wxPyEndAllowThreads(__tstate);
51886 if (PyErr_Occurred()) SWIG_fail;
51887 }
51888 resultobj = SWIG_Py_Void();
51889 return resultobj;
51890 fail:
51891 return NULL;
51892 }
51893
51894
51895 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51896 PyObject *resultobj = 0;
51897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51898 int result;
51899 void *argp1 = 0 ;
51900 int res1 = 0 ;
51901 PyObject *swig_obj[1] ;
51902
51903 if (!args) SWIG_fail;
51904 swig_obj[0] = args;
51905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51906 if (!SWIG_IsOK(res1)) {
51907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51908 }
51909 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51910 {
51911 PyThreadState* __tstate = wxPyBeginAllowThreads();
51912 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51913 wxPyEndAllowThreads(__tstate);
51914 if (PyErr_Occurred()) SWIG_fail;
51915 }
51916 resultobj = SWIG_From_int(static_cast< int >(result));
51917 return resultobj;
51918 fail:
51919 return NULL;
51920 }
51921
51922
51923 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51924 PyObject *resultobj = 0;
51925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51926 int result;
51927 void *argp1 = 0 ;
51928 int res1 = 0 ;
51929 PyObject *swig_obj[1] ;
51930
51931 if (!args) SWIG_fail;
51932 swig_obj[0] = args;
51933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51934 if (!SWIG_IsOK(res1)) {
51935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51936 }
51937 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51938 {
51939 PyThreadState* __tstate = wxPyBeginAllowThreads();
51940 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51941 wxPyEndAllowThreads(__tstate);
51942 if (PyErr_Occurred()) SWIG_fail;
51943 }
51944 resultobj = SWIG_From_int(static_cast< int >(result));
51945 return resultobj;
51946 fail:
51947 return NULL;
51948 }
51949
51950
51951 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51952 PyObject *resultobj = 0;
51953 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51954 int result;
51955 void *argp1 = 0 ;
51956 int res1 = 0 ;
51957 PyObject *swig_obj[1] ;
51958
51959 if (!args) SWIG_fail;
51960 swig_obj[0] = args;
51961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51962 if (!SWIG_IsOK(res1)) {
51963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51964 }
51965 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51966 {
51967 PyThreadState* __tstate = wxPyBeginAllowThreads();
51968 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51969 wxPyEndAllowThreads(__tstate);
51970 if (PyErr_Occurred()) SWIG_fail;
51971 }
51972 resultobj = SWIG_From_int(static_cast< int >(result));
51973 return resultobj;
51974 fail:
51975 return NULL;
51976 }
51977
51978
51979 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51980 PyObject *resultobj = 0;
51981 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51982 bool result;
51983 void *argp1 = 0 ;
51984 int res1 = 0 ;
51985 PyObject *swig_obj[1] ;
51986
51987 if (!args) SWIG_fail;
51988 swig_obj[0] = args;
51989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51992 }
51993 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51994 {
51995 PyThreadState* __tstate = wxPyBeginAllowThreads();
51996 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51997 wxPyEndAllowThreads(__tstate);
51998 if (PyErr_Occurred()) SWIG_fail;
51999 }
52000 {
52001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52002 }
52003 return resultobj;
52004 fail:
52005 return NULL;
52006 }
52007
52008
52009 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52010 PyObject *resultobj = 0;
52011 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52012 bool arg2 ;
52013 void *argp1 = 0 ;
52014 int res1 = 0 ;
52015 bool val2 ;
52016 int ecode2 = 0 ;
52017 PyObject * obj0 = 0 ;
52018 PyObject * obj1 = 0 ;
52019 char * kwnames[] = {
52020 (char *) "self",(char *) "d", NULL
52021 };
52022
52023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52025 if (!SWIG_IsOK(res1)) {
52026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52027 }
52028 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52030 if (!SWIG_IsOK(ecode2)) {
52031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52032 }
52033 arg2 = static_cast< bool >(val2);
52034 {
52035 PyThreadState* __tstate = wxPyBeginAllowThreads();
52036 (arg1)->SetDone(arg2);
52037 wxPyEndAllowThreads(__tstate);
52038 if (PyErr_Occurred()) SWIG_fail;
52039 }
52040 resultobj = SWIG_Py_Void();
52041 return resultobj;
52042 fail:
52043 return NULL;
52044 }
52045
52046
52047 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52048 PyObject *resultobj = 0;
52049 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52050 wxRelationship result;
52051 void *argp1 = 0 ;
52052 int res1 = 0 ;
52053 PyObject *swig_obj[1] ;
52054
52055 if (!args) SWIG_fail;
52056 swig_obj[0] = args;
52057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52058 if (!SWIG_IsOK(res1)) {
52059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52060 }
52061 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52062 {
52063 PyThreadState* __tstate = wxPyBeginAllowThreads();
52064 result = (wxRelationship)(arg1)->GetRelationship();
52065 wxPyEndAllowThreads(__tstate);
52066 if (PyErr_Occurred()) SWIG_fail;
52067 }
52068 resultobj = SWIG_From_int(static_cast< int >(result));
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52076 PyObject *resultobj = 0;
52077 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52078 wxRelationship arg2 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 int val2 ;
52082 int ecode2 = 0 ;
52083 PyObject * obj0 = 0 ;
52084 PyObject * obj1 = 0 ;
52085 char * kwnames[] = {
52086 (char *) "self",(char *) "r", NULL
52087 };
52088
52089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52093 }
52094 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52095 ecode2 = SWIG_AsVal_int(obj1, &val2);
52096 if (!SWIG_IsOK(ecode2)) {
52097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52098 }
52099 arg2 = static_cast< wxRelationship >(val2);
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 (arg1)->SetRelationship(arg2);
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 resultobj = SWIG_Py_Void();
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52114 PyObject *resultobj = 0;
52115 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52116 wxWindow *arg2 = (wxWindow *) 0 ;
52117 bool result;
52118 void *argp1 = 0 ;
52119 int res1 = 0 ;
52120 void *argp2 = 0 ;
52121 int res2 = 0 ;
52122 PyObject * obj0 = 0 ;
52123 PyObject * obj1 = 0 ;
52124 char * kwnames[] = {
52125 (char *) "self",(char *) "otherW", NULL
52126 };
52127
52128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52130 if (!SWIG_IsOK(res1)) {
52131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52132 }
52133 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52135 if (!SWIG_IsOK(res2)) {
52136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52137 }
52138 arg2 = reinterpret_cast< wxWindow * >(argp2);
52139 {
52140 PyThreadState* __tstate = wxPyBeginAllowThreads();
52141 result = (bool)(arg1)->ResetIfWin(arg2);
52142 wxPyEndAllowThreads(__tstate);
52143 if (PyErr_Occurred()) SWIG_fail;
52144 }
52145 {
52146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52147 }
52148 return resultobj;
52149 fail:
52150 return NULL;
52151 }
52152
52153
52154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52155 PyObject *resultobj = 0;
52156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52157 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52158 wxWindow *arg3 = (wxWindow *) 0 ;
52159 bool result;
52160 void *argp1 = 0 ;
52161 int res1 = 0 ;
52162 void *argp2 = 0 ;
52163 int res2 = 0 ;
52164 void *argp3 = 0 ;
52165 int res3 = 0 ;
52166 PyObject * obj0 = 0 ;
52167 PyObject * obj1 = 0 ;
52168 PyObject * obj2 = 0 ;
52169 char * kwnames[] = {
52170 (char *) "self",(char *) "constraints",(char *) "win", NULL
52171 };
52172
52173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52175 if (!SWIG_IsOK(res1)) {
52176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52177 }
52178 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52180 if (!SWIG_IsOK(res2)) {
52181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52182 }
52183 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52184 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52185 if (!SWIG_IsOK(res3)) {
52186 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52187 }
52188 arg3 = reinterpret_cast< wxWindow * >(argp3);
52189 {
52190 PyThreadState* __tstate = wxPyBeginAllowThreads();
52191 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52192 wxPyEndAllowThreads(__tstate);
52193 if (PyErr_Occurred()) SWIG_fail;
52194 }
52195 {
52196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52197 }
52198 return resultobj;
52199 fail:
52200 return NULL;
52201 }
52202
52203
52204 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52205 PyObject *resultobj = 0;
52206 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52207 wxEdge arg2 ;
52208 wxWindow *arg3 = (wxWindow *) 0 ;
52209 wxWindow *arg4 = (wxWindow *) 0 ;
52210 int result;
52211 void *argp1 = 0 ;
52212 int res1 = 0 ;
52213 int val2 ;
52214 int ecode2 = 0 ;
52215 void *argp3 = 0 ;
52216 int res3 = 0 ;
52217 void *argp4 = 0 ;
52218 int res4 = 0 ;
52219 PyObject * obj0 = 0 ;
52220 PyObject * obj1 = 0 ;
52221 PyObject * obj2 = 0 ;
52222 PyObject * obj3 = 0 ;
52223 char * kwnames[] = {
52224 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52225 };
52226
52227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52229 if (!SWIG_IsOK(res1)) {
52230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52231 }
52232 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52233 ecode2 = SWIG_AsVal_int(obj1, &val2);
52234 if (!SWIG_IsOK(ecode2)) {
52235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52236 }
52237 arg2 = static_cast< wxEdge >(val2);
52238 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52239 if (!SWIG_IsOK(res3)) {
52240 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52241 }
52242 arg3 = reinterpret_cast< wxWindow * >(argp3);
52243 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52244 if (!SWIG_IsOK(res4)) {
52245 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52246 }
52247 arg4 = reinterpret_cast< wxWindow * >(argp4);
52248 {
52249 PyThreadState* __tstate = wxPyBeginAllowThreads();
52250 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52251 wxPyEndAllowThreads(__tstate);
52252 if (PyErr_Occurred()) SWIG_fail;
52253 }
52254 resultobj = SWIG_From_int(static_cast< int >(result));
52255 return resultobj;
52256 fail:
52257 return NULL;
52258 }
52259
52260
52261 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52262 PyObject *obj;
52263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52264 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52265 return SWIG_Py_Void();
52266 }
52267
52268 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52269 PyObject *resultobj = 0;
52270 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52271 wxIndividualLayoutConstraint *result = 0 ;
52272 void *argp1 = 0 ;
52273 int res1 = 0 ;
52274 PyObject *swig_obj[1] ;
52275
52276 if (!args) SWIG_fail;
52277 swig_obj[0] = args;
52278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52281 }
52282 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52283 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52285 return resultobj;
52286 fail:
52287 return NULL;
52288 }
52289
52290
52291 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52292 PyObject *resultobj = 0;
52293 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52294 wxIndividualLayoutConstraint *result = 0 ;
52295 void *argp1 = 0 ;
52296 int res1 = 0 ;
52297 PyObject *swig_obj[1] ;
52298
52299 if (!args) SWIG_fail;
52300 swig_obj[0] = args;
52301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52302 if (!SWIG_IsOK(res1)) {
52303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52304 }
52305 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52306 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52308 return resultobj;
52309 fail:
52310 return NULL;
52311 }
52312
52313
52314 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52315 PyObject *resultobj = 0;
52316 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52317 wxIndividualLayoutConstraint *result = 0 ;
52318 void *argp1 = 0 ;
52319 int res1 = 0 ;
52320 PyObject *swig_obj[1] ;
52321
52322 if (!args) SWIG_fail;
52323 swig_obj[0] = args;
52324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52325 if (!SWIG_IsOK(res1)) {
52326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52327 }
52328 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52329 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52331 return resultobj;
52332 fail:
52333 return NULL;
52334 }
52335
52336
52337 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52338 PyObject *resultobj = 0;
52339 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52340 wxIndividualLayoutConstraint *result = 0 ;
52341 void *argp1 = 0 ;
52342 int res1 = 0 ;
52343 PyObject *swig_obj[1] ;
52344
52345 if (!args) SWIG_fail;
52346 swig_obj[0] = args;
52347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52348 if (!SWIG_IsOK(res1)) {
52349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52350 }
52351 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52352 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52354 return resultobj;
52355 fail:
52356 return NULL;
52357 }
52358
52359
52360 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52361 PyObject *resultobj = 0;
52362 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52363 wxIndividualLayoutConstraint *result = 0 ;
52364 void *argp1 = 0 ;
52365 int res1 = 0 ;
52366 PyObject *swig_obj[1] ;
52367
52368 if (!args) SWIG_fail;
52369 swig_obj[0] = args;
52370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52371 if (!SWIG_IsOK(res1)) {
52372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52373 }
52374 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52375 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52377 return resultobj;
52378 fail:
52379 return NULL;
52380 }
52381
52382
52383 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52384 PyObject *resultobj = 0;
52385 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52386 wxIndividualLayoutConstraint *result = 0 ;
52387 void *argp1 = 0 ;
52388 int res1 = 0 ;
52389 PyObject *swig_obj[1] ;
52390
52391 if (!args) SWIG_fail;
52392 swig_obj[0] = args;
52393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52394 if (!SWIG_IsOK(res1)) {
52395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52396 }
52397 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52398 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52400 return resultobj;
52401 fail:
52402 return NULL;
52403 }
52404
52405
52406 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52407 PyObject *resultobj = 0;
52408 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52409 wxIndividualLayoutConstraint *result = 0 ;
52410 void *argp1 = 0 ;
52411 int res1 = 0 ;
52412 PyObject *swig_obj[1] ;
52413
52414 if (!args) SWIG_fail;
52415 swig_obj[0] = args;
52416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52417 if (!SWIG_IsOK(res1)) {
52418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52419 }
52420 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52421 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52423 return resultobj;
52424 fail:
52425 return NULL;
52426 }
52427
52428
52429 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52430 PyObject *resultobj = 0;
52431 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52432 wxIndividualLayoutConstraint *result = 0 ;
52433 void *argp1 = 0 ;
52434 int res1 = 0 ;
52435 PyObject *swig_obj[1] ;
52436
52437 if (!args) SWIG_fail;
52438 swig_obj[0] = args;
52439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52440 if (!SWIG_IsOK(res1)) {
52441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52442 }
52443 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52444 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52446 return resultobj;
52447 fail:
52448 return NULL;
52449 }
52450
52451
52452 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52453 PyObject *resultobj = 0;
52454 wxLayoutConstraints *result = 0 ;
52455
52456 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52457 {
52458 PyThreadState* __tstate = wxPyBeginAllowThreads();
52459 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52460 wxPyEndAllowThreads(__tstate);
52461 if (PyErr_Occurred()) SWIG_fail;
52462 }
52463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52464 return resultobj;
52465 fail:
52466 return NULL;
52467 }
52468
52469
52470 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52471 PyObject *resultobj = 0;
52472 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52473 void *argp1 = 0 ;
52474 int res1 = 0 ;
52475 PyObject *swig_obj[1] ;
52476
52477 if (!args) SWIG_fail;
52478 swig_obj[0] = args;
52479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52480 if (!SWIG_IsOK(res1)) {
52481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52482 }
52483 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52484 {
52485 PyThreadState* __tstate = wxPyBeginAllowThreads();
52486 delete arg1;
52487
52488 wxPyEndAllowThreads(__tstate);
52489 if (PyErr_Occurred()) SWIG_fail;
52490 }
52491 resultobj = SWIG_Py_Void();
52492 return resultobj;
52493 fail:
52494 return NULL;
52495 }
52496
52497
52498 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52499 PyObject *resultobj = 0;
52500 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52501 wxWindow *arg2 = (wxWindow *) 0 ;
52502 int *arg3 = (int *) 0 ;
52503 bool result;
52504 void *argp1 = 0 ;
52505 int res1 = 0 ;
52506 void *argp2 = 0 ;
52507 int res2 = 0 ;
52508 int temp3 ;
52509 int res3 = SWIG_TMPOBJ ;
52510 PyObject * obj0 = 0 ;
52511 PyObject * obj1 = 0 ;
52512 char * kwnames[] = {
52513 (char *) "self",(char *) "win", NULL
52514 };
52515
52516 arg3 = &temp3;
52517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52519 if (!SWIG_IsOK(res1)) {
52520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52521 }
52522 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52524 if (!SWIG_IsOK(res2)) {
52525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52526 }
52527 arg2 = reinterpret_cast< wxWindow * >(argp2);
52528 {
52529 PyThreadState* __tstate = wxPyBeginAllowThreads();
52530 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52531 wxPyEndAllowThreads(__tstate);
52532 if (PyErr_Occurred()) SWIG_fail;
52533 }
52534 {
52535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52536 }
52537 if (SWIG_IsTmpObj(res3)) {
52538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52539 } else {
52540 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52542 }
52543 return resultobj;
52544 fail:
52545 return NULL;
52546 }
52547
52548
52549 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52550 PyObject *resultobj = 0;
52551 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52552 bool result;
52553 void *argp1 = 0 ;
52554 int res1 = 0 ;
52555 PyObject *swig_obj[1] ;
52556
52557 if (!args) SWIG_fail;
52558 swig_obj[0] = args;
52559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52560 if (!SWIG_IsOK(res1)) {
52561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52562 }
52563 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52564 {
52565 PyThreadState* __tstate = wxPyBeginAllowThreads();
52566 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52567 wxPyEndAllowThreads(__tstate);
52568 if (PyErr_Occurred()) SWIG_fail;
52569 }
52570 {
52571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52572 }
52573 return resultobj;
52574 fail:
52575 return NULL;
52576 }
52577
52578
52579 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52580 PyObject *obj;
52581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52582 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52583 return SWIG_Py_Void();
52584 }
52585
52586 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52587 return SWIG_Python_InitShadowInstance(args);
52588 }
52589
52590 static PyMethodDef SwigMethods[] = {
52591 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52592 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52593 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52594 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52595 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52596 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52597 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52598 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52599 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52601 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52607 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52611 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52612 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52613 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52615 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52616 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52617 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52618 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52619 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52620 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52621 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52623 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52629 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52630 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52631 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52632 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52633 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52634 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52635 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52637 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52640 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52645 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52646 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52647 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52652 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52653 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52655 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52657 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52659 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52661 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52663 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52665 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52666 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52668 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52670 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52671 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52672 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52673 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52692 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52693 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52694 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52695 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52696 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52697 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52698 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52699 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52701 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52702 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52703 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52704 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52708 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52709 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52710 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52711 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52718 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52725 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52726 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52727 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52728 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52730 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52731 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52732 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52734 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52735 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52736 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52737 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52742 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52743 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52744 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52745 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52746 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52747 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52750 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52751 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52752 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52754 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52755 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52757 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52758 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52759 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52760 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52761 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52762 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52763 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52764 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52765 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52766 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52767 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52772 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52778 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52779 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52780 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52781 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52783 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52786 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52788 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52791 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52792 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52793 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52796 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52797 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52798 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52802 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52803 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52804 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52808 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52813 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52814 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52815 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52816 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52817 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52818 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52819 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52825 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52826 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52828 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52829 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52830 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52836 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52837 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52839 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52840 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52841 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52842 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52843 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52844 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52845 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52846 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52848 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52849 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52850 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52851 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52852 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52853 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52854 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52855 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52857 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52866 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52868 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52878 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52879 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52894 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52895 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52896 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52897 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52900 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52902 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52904 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52906 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52908 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52911 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52912 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52913 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52914 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52916 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52933 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52934 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52940 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52941 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52942 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52943 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52944 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52945 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52946 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52947 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52948 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52949 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52951 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52952 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52953 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52954 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52955 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52956 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52957 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52958 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52959 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52960 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52961 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52962 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52963 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52964 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52965 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52966 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52967 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52968 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52969 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52970 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52971 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52972 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52973 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52974 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52976 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52977 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52978 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52979 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52982 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52986 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52990 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52991 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52992 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52993 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52995 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52996 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52998 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53000 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53002 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53004 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53005 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53006 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53008 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53009 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53011 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53012 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53015 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53016 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53017 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53019 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53021 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53022 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53023 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53025 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53027 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53028 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53030 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53031 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53032 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53034 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53035 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53036 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53037 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53038 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53040 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53041 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53044 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53045 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53047 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53048 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53051 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53052 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53054 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53060 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53061 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53062 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53063 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53064 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53065 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53066 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53067 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53068 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53069 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53070 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53071 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53072 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53073 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53074 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53075 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53076 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53077 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53078 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53079 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53080 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53081 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53082 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53083 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53085 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53086 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53087 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53088 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53089 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53090 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53091 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53092 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53093 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53094 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53095 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53096 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53097 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53098 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53099 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53100 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53101 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53102 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53103 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53104 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53105 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53106 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53107 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53108 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53109 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53110 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53111 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53112 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53113 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53114 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53115 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53116 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53118 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53119 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53121 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53122 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53123 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53124 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53126 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53127 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53128 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53129 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53130 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53131 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53132 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53133 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53134 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53135 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53136 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53137 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53138 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53139 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53140 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53141 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53142 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53143 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53144 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53145 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53146 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53147 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53148 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53149 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53150 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53151 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53152 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53153 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53154 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53155 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53156 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53157 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53158 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53159 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53160 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53161 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53162 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53164 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53165 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53168 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53169 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53170 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53171 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53173 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53175 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53176 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53179 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53182 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53185 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53186 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53188 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53189 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53190 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53192 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53194 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53197 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53198 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53201 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53202 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53205 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53206 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53208 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53209 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53210 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53211 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53212 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53215 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53217 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53219 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53220 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53221 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53224 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53225 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53226 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53228 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53229 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53230 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53232 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53233 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53234 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53235 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53236 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53237 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53239 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53240 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53241 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53242 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53243 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53244 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53245 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53246 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53252 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53254 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53256 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53257 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53258 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53259 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53260 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53261 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53263 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53264 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53265 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53266 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53267 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53268 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53271 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53272 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53273 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53276 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53277 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53278 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53279 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53280 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53282 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53284 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53287 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53289 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53290 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53292 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53293 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53294 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53296 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53297 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53298 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53300 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53302 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53303 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53304 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53306 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53308 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53310 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53311 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53313 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53314 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53316 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53318 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53319 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53320 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53322 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53324 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53325 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53326 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53328 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53330 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53331 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53332 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53333 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53335 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53337 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53339 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53341 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53342 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53344 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53345 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53346 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53347 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53348 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53349 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53350 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53351 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53353 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53355 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53357 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53359 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53361 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53363 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53364 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53365 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53366 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53367 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53368 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53374 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53375 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53376 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53377 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53378 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53379 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53380 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53382 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53384 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53385 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53387 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53388 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53389 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53390 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53392 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53393 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53394 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53395 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53397 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53398 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53400 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53401 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53402 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53404 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53406 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53407 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53408 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53409 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53410 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53412 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53413 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53414 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53415 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53417 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53418 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53419 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53420 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53421 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53422 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53423 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53424 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53425 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53428 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53431 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53432 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53433 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53435 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53437 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53439 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53441 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53442 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53452 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53453 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53457 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53458 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53459 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53460 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53461 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53462 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53463 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53464 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53465 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53466 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53467 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53468 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53469 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53470 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53471 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53473 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53474 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53477 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53478 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53483 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53484 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53487 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53488 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53489 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53490 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53493 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53494 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53495 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53497 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53499 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53500 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53501 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53503 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53505 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53507 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53510 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53511 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53512 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53513 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53514 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53515 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53516 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53522 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53523 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53524 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53525 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53532 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53538 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53539 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53540 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53541 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53542 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53544 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53554 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53555 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53556 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53557 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53560 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53561 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53562 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53563 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53565 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53566 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53570 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53576 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53577 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53578 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53579 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53581 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53582 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53584 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53587 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53589 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53590 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53591 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53600 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53604 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53606 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53617 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53618 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53619 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53620 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53623 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53626 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53628 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53631 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53633 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53634 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53637 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53639 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53640 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53641 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53642 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53643 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53648 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53649 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53650 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53652 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53653 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53654 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53656 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53658 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53659 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53660 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53662 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53666 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53674 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53681 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53689 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53692 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53693 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53706 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53708 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53710 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53711 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53713 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53715 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53716 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53718 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53719 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53720 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53724 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53743 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53744 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53746 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53748 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53749 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53750 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53752 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53753 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53756 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53757 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53759 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53760 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53762 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53765 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53766 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53768 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53770 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53772 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53773 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53775 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53776 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53779 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53781 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53783 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53785 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53788 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53790 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53791 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53792 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53794 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53795 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53796 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53798 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53801 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53803 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53804 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53808 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53812 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53813 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53815 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53819 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53821 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53823 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53824 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53825 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53826 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53830 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53831 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53832 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53833 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53835 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53836 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53841 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53842 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53843 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53844 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53845 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53847 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53849 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53851 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53852 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53854 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53856 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53859 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53860 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53861 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53863 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53864 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53865 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53879 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53880 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53881 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53882 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53883 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53884 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53890 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53891 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53895 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53896 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53898 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53899 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53901 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53903 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53906 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53907 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53908 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53914 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53915 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53916 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53917 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53918 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53919 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53926 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53928 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53929 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53930 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53931 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53932 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53933 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53935 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53939 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53940 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53941 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53942 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53943 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53944 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53945 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53947 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53948 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53949 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53955 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53956 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53957 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53959 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53960 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53961 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53967 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53968 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53969 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53970 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53971 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53975 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53976 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53981 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53982 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53984 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53985 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53990 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53992 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53993 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53994 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53995 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53996 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54001 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54002 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54011 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54012 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54013 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54014 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54017 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54019 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54020 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54021 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54022 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54024 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54029 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54030 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54031 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54032 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54033 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54034 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54035 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54036 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54037 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54038 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54039 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54041 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54042 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54043 { NULL, NULL, 0, NULL }
54044 };
54045
54046
54047 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54048
54049 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54050 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54051 }
54052 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54053 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54054 }
54055 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54056 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54057 }
54058 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54059 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54060 }
54061 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54062 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54063 }
54064 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54065 return (void *)((wxSizer *) ((wxGridSizer *) x));
54066 }
54067 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54068 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54069 }
54070 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54071 return (void *)((wxSizer *) ((wxPySizer *) x));
54072 }
54073 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54074 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54075 }
54076 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54077 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54078 }
54079 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54080 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54081 }
54082 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54083 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54084 }
54085 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54086 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54087 }
54088 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54089 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54090 }
54091 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54092 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54093 }
54094 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54095 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54096 }
54097 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54098 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54099 }
54100 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54101 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54102 }
54103 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54104 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54105 }
54106 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54107 return (void *)((wxEvent *) ((wxPyEvent *) x));
54108 }
54109 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54110 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54111 }
54112 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54113 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54114 }
54115 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54116 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54117 }
54118 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54119 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54120 }
54121 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54122 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54123 }
54124 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54125 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54126 }
54127 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54128 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54129 }
54130 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54131 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54132 }
54133 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54134 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54135 }
54136 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54138 }
54139 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54140 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54141 }
54142 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54143 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54144 }
54145 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54146 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54147 }
54148 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54149 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54150 }
54151 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54152 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54153 }
54154 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54155 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54156 }
54157 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54158 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54159 }
54160 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54161 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54162 }
54163 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54164 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54165 }
54166 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54167 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54168 }
54169 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54170 return (void *)((wxEvent *) ((wxShowEvent *) x));
54171 }
54172 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54173 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54174 }
54175 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54176 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54177 }
54178 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54179 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54180 }
54181 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54182 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54183 }
54184 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54185 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54186 }
54187 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54188 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54189 }
54190 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54191 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54192 }
54193 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54194 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54195 }
54196 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54197 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54198 }
54199 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54200 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54201 }
54202 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54203 return (void *)((wxControl *) ((wxControlWithItems *) x));
54204 }
54205 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54206 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54207 }
54208 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54209 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54210 }
54211 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54212 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54213 }
54214 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54215 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54216 }
54217 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54218 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54219 }
54220 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54221 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54222 }
54223 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54224 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54225 }
54226 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54227 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54228 }
54229 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54230 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54231 }
54232 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54233 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54234 }
54235 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54236 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54237 }
54238 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54239 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54240 }
54241 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54242 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54243 }
54244 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54245 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54246 }
54247 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54248 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54249 }
54250 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54251 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54252 }
54253 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54254 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54255 }
54256 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54257 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54258 }
54259 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54260 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54261 }
54262 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54263 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54264 }
54265 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54266 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54267 }
54268 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54269 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54270 }
54271 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54272 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54273 }
54274 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54275 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54276 }
54277 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54278 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54279 }
54280 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54281 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54282 }
54283 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54284 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54285 }
54286 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54287 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54288 }
54289 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54290 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54291 }
54292 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54293 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54294 }
54295 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54296 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54297 }
54298 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54299 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54300 }
54301 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54302 return (void *)((wxObject *) ((wxSizerItem *) x));
54303 }
54304 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54305 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54306 }
54307 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54308 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54309 }
54310 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54311 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54312 }
54313 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54314 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54315 }
54316 static void *_p_wxSizerTo_p_wxObject(void *x) {
54317 return (void *)((wxObject *) ((wxSizer *) x));
54318 }
54319 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54320 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54321 }
54322 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54323 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54324 }
54325 static void *_p_wxEventTo_p_wxObject(void *x) {
54326 return (void *)((wxObject *) ((wxEvent *) x));
54327 }
54328 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54329 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54330 }
54331 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54332 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54333 }
54334 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54335 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54336 }
54337 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54338 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54339 }
54340 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54341 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54342 }
54343 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54344 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54345 }
54346 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54347 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54348 }
54349 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54350 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54351 }
54352 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54353 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54354 }
54355 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54356 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54357 }
54358 static void *_p_wxControlTo_p_wxObject(void *x) {
54359 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54360 }
54361 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54362 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54363 }
54364 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54365 return (void *)((wxObject *) ((wxFSFile *) x));
54366 }
54367 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54368 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54369 }
54370 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54371 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54372 }
54373 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54375 }
54376 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54378 }
54379 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) ((wxMenuItem *) x));
54381 }
54382 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54384 }
54385 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54387 }
54388 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54390 }
54391 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54393 }
54394 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54395 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54396 }
54397 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54398 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54399 }
54400 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54401 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54402 }
54403 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54404 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54405 }
54406 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54407 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54408 }
54409 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54410 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54411 }
54412 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54413 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54414 }
54415 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54416 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54417 }
54418 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54419 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54420 }
54421 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54422 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54423 }
54424 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54425 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54426 }
54427 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54428 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54429 }
54430 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54431 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54432 }
54433 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54434 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54435 }
54436 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54437 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54438 }
54439 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54440 return (void *)((wxObject *) ((wxImageHandler *) x));
54441 }
54442 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54443 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54444 }
54445 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54446 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54447 }
54448 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54449 return (void *)((wxObject *) ((wxEvtHandler *) x));
54450 }
54451 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54452 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54453 }
54454 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54455 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54456 }
54457 static void *_p_wxImageTo_p_wxObject(void *x) {
54458 return (void *)((wxObject *) ((wxImage *) x));
54459 }
54460 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54462 }
54463 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54465 }
54466 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54468 }
54469 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54471 }
54472 static void *_p_wxWindowTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54474 }
54475 static void *_p_wxMenuTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54477 }
54478 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54480 }
54481 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) ((wxFileSystem *) x));
54483 }
54484 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54486 }
54487 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54489 }
54490 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54492 }
54493 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54495 }
54496 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54498 }
54499 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54500 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54501 }
54502 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54503 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54504 }
54505 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54506 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54507 }
54508 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54509 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54510 }
54511 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54512 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54513 }
54514 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54516 }
54517 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54519 }
54520 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54522 }
54523 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54525 }
54526 static void *_p_wxControlTo_p_wxWindow(void *x) {
54527 return (void *)((wxWindow *) ((wxControl *) x));
54528 }
54529 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54530 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54531 }
54532 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54533 return (void *)((wxWindow *) ((wxMenuBar *) x));
54534 }
54535 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54536 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54537 }
54538 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54539 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54540 }
54541 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54542 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54543 }
54544 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54545 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54546 }
54547 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54548 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54549 }
54550 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54551 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54552 }
54553 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54554 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54555 }
54556 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54557 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54558 }
54559 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54560 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54561 }
54562 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54563 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54564 }
54565 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54566 return (void *)((wxValidator *) ((wxPyValidator *) x));
54567 }
54568 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54570 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};
54571 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54631 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54632 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54633 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54634 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54635 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54636 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54637 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54638 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54639 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54640 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54641 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54642 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54643 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54644 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54645 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54646 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54647 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54648 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54649 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54658 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54659 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54660 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54661 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54662 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54663 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54664 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54665 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54666 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54667 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54668 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54669 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54670 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54671 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54672 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54673 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54674 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54675 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54676 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54677 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54678 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54679 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54680 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54681 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54682 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54683 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54684 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54685 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54686 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54687 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54688 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54689 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54690 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54691 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54692 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54693 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54694 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54695 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54696 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54697 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54698
54699 static swig_type_info *swig_type_initial[] = {
54700 &_swigt__p_buffer,
54701 &_swigt__p_char,
54702 &_swigt__p_form_ops_t,
54703 &_swigt__p_int,
54704 &_swigt__p_long,
54705 &_swigt__p_unsigned_char,
54706 &_swigt__p_unsigned_int,
54707 &_swigt__p_unsigned_long,
54708 &_swigt__p_wxANIHandler,
54709 &_swigt__p_wxAcceleratorEntry,
54710 &_swigt__p_wxAcceleratorTable,
54711 &_swigt__p_wxActivateEvent,
54712 &_swigt__p_wxAppTraits,
54713 &_swigt__p_wxArrayString,
54714 &_swigt__p_wxBMPHandler,
54715 &_swigt__p_wxBitmap,
54716 &_swigt__p_wxBoxSizer,
54717 &_swigt__p_wxButton,
54718 &_swigt__p_wxCURHandler,
54719 &_swigt__p_wxCaret,
54720 &_swigt__p_wxChildFocusEvent,
54721 &_swigt__p_wxClipboardTextEvent,
54722 &_swigt__p_wxCloseEvent,
54723 &_swigt__p_wxColour,
54724 &_swigt__p_wxCommandEvent,
54725 &_swigt__p_wxContextMenuEvent,
54726 &_swigt__p_wxControl,
54727 &_swigt__p_wxControlWithItems,
54728 &_swigt__p_wxCursor,
54729 &_swigt__p_wxDC,
54730 &_swigt__p_wxDateEvent,
54731 &_swigt__p_wxDateTime,
54732 &_swigt__p_wxDisplayChangedEvent,
54733 &_swigt__p_wxDropFilesEvent,
54734 &_swigt__p_wxDuplexMode,
54735 &_swigt__p_wxEraseEvent,
54736 &_swigt__p_wxEvent,
54737 &_swigt__p_wxEventLoop,
54738 &_swigt__p_wxEventLoopActivator,
54739 &_swigt__p_wxEvtHandler,
54740 &_swigt__p_wxFSFile,
54741 &_swigt__p_wxFileSystem,
54742 &_swigt__p_wxFileSystemHandler,
54743 &_swigt__p_wxFlexGridSizer,
54744 &_swigt__p_wxFocusEvent,
54745 &_swigt__p_wxFont,
54746 &_swigt__p_wxFrame,
54747 &_swigt__p_wxGBPosition,
54748 &_swigt__p_wxGBSizerItem,
54749 &_swigt__p_wxGBSpan,
54750 &_swigt__p_wxGIFHandler,
54751 &_swigt__p_wxGridBagSizer,
54752 &_swigt__p_wxGridSizer,
54753 &_swigt__p_wxICOHandler,
54754 &_swigt__p_wxIconizeEvent,
54755 &_swigt__p_wxIdleEvent,
54756 &_swigt__p_wxImage,
54757 &_swigt__p_wxImageHandler,
54758 &_swigt__p_wxImageHistogram,
54759 &_swigt__p_wxImage_HSVValue,
54760 &_swigt__p_wxImage_RGBValue,
54761 &_swigt__p_wxIndividualLayoutConstraint,
54762 &_swigt__p_wxInitDialogEvent,
54763 &_swigt__p_wxInputStream,
54764 &_swigt__p_wxInternetFSHandler,
54765 &_swigt__p_wxItemContainer,
54766 &_swigt__p_wxJPEGHandler,
54767 &_swigt__p_wxKeyEvent,
54768 &_swigt__p_wxLayoutConstraints,
54769 &_swigt__p_wxMaximizeEvent,
54770 &_swigt__p_wxMemoryFSHandler,
54771 &_swigt__p_wxMenu,
54772 &_swigt__p_wxMenuBar,
54773 &_swigt__p_wxMenuBarBase,
54774 &_swigt__p_wxMenuEvent,
54775 &_swigt__p_wxMenuItem,
54776 &_swigt__p_wxMouseCaptureChangedEvent,
54777 &_swigt__p_wxMouseEvent,
54778 &_swigt__p_wxMoveEvent,
54779 &_swigt__p_wxNavigationKeyEvent,
54780 &_swigt__p_wxNcPaintEvent,
54781 &_swigt__p_wxNotifyEvent,
54782 &_swigt__p_wxObject,
54783 &_swigt__p_wxOutputStream,
54784 &_swigt__p_wxPCXHandler,
54785 &_swigt__p_wxPNGHandler,
54786 &_swigt__p_wxPNMHandler,
54787 &_swigt__p_wxPaintEvent,
54788 &_swigt__p_wxPaletteChangedEvent,
54789 &_swigt__p_wxPaperSize,
54790 &_swigt__p_wxPoint,
54791 &_swigt__p_wxPoint2D,
54792 &_swigt__p_wxPropagateOnce,
54793 &_swigt__p_wxPropagationDisabler,
54794 &_swigt__p_wxPyApp,
54795 &_swigt__p_wxPyCommandEvent,
54796 &_swigt__p_wxPyDropTarget,
54797 &_swigt__p_wxPyEvent,
54798 &_swigt__p_wxPyFileSystemHandler,
54799 &_swigt__p_wxPyImageHandler,
54800 &_swigt__p_wxPyInputStream,
54801 &_swigt__p_wxPySizer,
54802 &_swigt__p_wxPyValidator,
54803 &_swigt__p_wxQuantize,
54804 &_swigt__p_wxQueryNewPaletteEvent,
54805 &_swigt__p_wxRealPoint,
54806 &_swigt__p_wxRect,
54807 &_swigt__p_wxRegion,
54808 &_swigt__p_wxScrollEvent,
54809 &_swigt__p_wxScrollWinEvent,
54810 &_swigt__p_wxSetCursorEvent,
54811 &_swigt__p_wxShowEvent,
54812 &_swigt__p_wxSize,
54813 &_swigt__p_wxSizeEvent,
54814 &_swigt__p_wxSizer,
54815 &_swigt__p_wxSizerItem,
54816 &_swigt__p_wxStaticBox,
54817 &_swigt__p_wxStaticBoxSizer,
54818 &_swigt__p_wxStdDialogButtonSizer,
54819 &_swigt__p_wxSysColourChangedEvent,
54820 &_swigt__p_wxTIFFHandler,
54821 &_swigt__p_wxToolTip,
54822 &_swigt__p_wxUpdateUIEvent,
54823 &_swigt__p_wxValidator,
54824 &_swigt__p_wxVisualAttributes,
54825 &_swigt__p_wxWindow,
54826 &_swigt__p_wxWindowCreateEvent,
54827 &_swigt__p_wxWindowDestroyEvent,
54828 &_swigt__p_wxXPMHandler,
54829 &_swigt__p_wxZipFSHandler,
54830 };
54831
54832 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54836 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54844 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54845 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54846 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}};
54847 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54848 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}};
54849 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54850 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}};
54851 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54856 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}};
54857 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54858 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}};
54859 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54860 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54862 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54863 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54864 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54870 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54871 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}};
54872 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54874 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}};
54875 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}};
54876 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54879 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54880 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54881 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54882 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54883 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54884 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}};
54885 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}};
54886 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54887 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54888 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54889 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}};
54890 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54891 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54892 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54893 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54895 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54896 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54897 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}};
54898 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54899 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54900 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54901 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54902 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54903 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54904 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54905 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54906 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54907 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54908 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54909 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54910 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54911 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54912 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54915 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54916 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54917 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54918 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54919 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54920 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54921 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54922 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54923 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54924 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54925 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54926 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54927 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54928 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54929 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54930 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54931 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54932 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54933 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54934 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54935 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54936 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54937 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54938 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54939 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54940 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54941 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54942 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54943 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54944 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54945 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54946 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}};
54947 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}};
54948 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54949 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54950 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54951 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54952 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54953 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54954 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54955 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}};
54956 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54957 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}};
54958 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54959 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54960 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54961 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54962
54963 static swig_cast_info *swig_cast_initial[] = {
54964 _swigc__p_buffer,
54965 _swigc__p_char,
54966 _swigc__p_form_ops_t,
54967 _swigc__p_int,
54968 _swigc__p_long,
54969 _swigc__p_unsigned_char,
54970 _swigc__p_unsigned_int,
54971 _swigc__p_unsigned_long,
54972 _swigc__p_wxANIHandler,
54973 _swigc__p_wxAcceleratorEntry,
54974 _swigc__p_wxAcceleratorTable,
54975 _swigc__p_wxActivateEvent,
54976 _swigc__p_wxAppTraits,
54977 _swigc__p_wxArrayString,
54978 _swigc__p_wxBMPHandler,
54979 _swigc__p_wxBitmap,
54980 _swigc__p_wxBoxSizer,
54981 _swigc__p_wxButton,
54982 _swigc__p_wxCURHandler,
54983 _swigc__p_wxCaret,
54984 _swigc__p_wxChildFocusEvent,
54985 _swigc__p_wxClipboardTextEvent,
54986 _swigc__p_wxCloseEvent,
54987 _swigc__p_wxColour,
54988 _swigc__p_wxCommandEvent,
54989 _swigc__p_wxContextMenuEvent,
54990 _swigc__p_wxControl,
54991 _swigc__p_wxControlWithItems,
54992 _swigc__p_wxCursor,
54993 _swigc__p_wxDC,
54994 _swigc__p_wxDateEvent,
54995 _swigc__p_wxDateTime,
54996 _swigc__p_wxDisplayChangedEvent,
54997 _swigc__p_wxDropFilesEvent,
54998 _swigc__p_wxDuplexMode,
54999 _swigc__p_wxEraseEvent,
55000 _swigc__p_wxEvent,
55001 _swigc__p_wxEventLoop,
55002 _swigc__p_wxEventLoopActivator,
55003 _swigc__p_wxEvtHandler,
55004 _swigc__p_wxFSFile,
55005 _swigc__p_wxFileSystem,
55006 _swigc__p_wxFileSystemHandler,
55007 _swigc__p_wxFlexGridSizer,
55008 _swigc__p_wxFocusEvent,
55009 _swigc__p_wxFont,
55010 _swigc__p_wxFrame,
55011 _swigc__p_wxGBPosition,
55012 _swigc__p_wxGBSizerItem,
55013 _swigc__p_wxGBSpan,
55014 _swigc__p_wxGIFHandler,
55015 _swigc__p_wxGridBagSizer,
55016 _swigc__p_wxGridSizer,
55017 _swigc__p_wxICOHandler,
55018 _swigc__p_wxIconizeEvent,
55019 _swigc__p_wxIdleEvent,
55020 _swigc__p_wxImage,
55021 _swigc__p_wxImageHandler,
55022 _swigc__p_wxImageHistogram,
55023 _swigc__p_wxImage_HSVValue,
55024 _swigc__p_wxImage_RGBValue,
55025 _swigc__p_wxIndividualLayoutConstraint,
55026 _swigc__p_wxInitDialogEvent,
55027 _swigc__p_wxInputStream,
55028 _swigc__p_wxInternetFSHandler,
55029 _swigc__p_wxItemContainer,
55030 _swigc__p_wxJPEGHandler,
55031 _swigc__p_wxKeyEvent,
55032 _swigc__p_wxLayoutConstraints,
55033 _swigc__p_wxMaximizeEvent,
55034 _swigc__p_wxMemoryFSHandler,
55035 _swigc__p_wxMenu,
55036 _swigc__p_wxMenuBar,
55037 _swigc__p_wxMenuBarBase,
55038 _swigc__p_wxMenuEvent,
55039 _swigc__p_wxMenuItem,
55040 _swigc__p_wxMouseCaptureChangedEvent,
55041 _swigc__p_wxMouseEvent,
55042 _swigc__p_wxMoveEvent,
55043 _swigc__p_wxNavigationKeyEvent,
55044 _swigc__p_wxNcPaintEvent,
55045 _swigc__p_wxNotifyEvent,
55046 _swigc__p_wxObject,
55047 _swigc__p_wxOutputStream,
55048 _swigc__p_wxPCXHandler,
55049 _swigc__p_wxPNGHandler,
55050 _swigc__p_wxPNMHandler,
55051 _swigc__p_wxPaintEvent,
55052 _swigc__p_wxPaletteChangedEvent,
55053 _swigc__p_wxPaperSize,
55054 _swigc__p_wxPoint,
55055 _swigc__p_wxPoint2D,
55056 _swigc__p_wxPropagateOnce,
55057 _swigc__p_wxPropagationDisabler,
55058 _swigc__p_wxPyApp,
55059 _swigc__p_wxPyCommandEvent,
55060 _swigc__p_wxPyDropTarget,
55061 _swigc__p_wxPyEvent,
55062 _swigc__p_wxPyFileSystemHandler,
55063 _swigc__p_wxPyImageHandler,
55064 _swigc__p_wxPyInputStream,
55065 _swigc__p_wxPySizer,
55066 _swigc__p_wxPyValidator,
55067 _swigc__p_wxQuantize,
55068 _swigc__p_wxQueryNewPaletteEvent,
55069 _swigc__p_wxRealPoint,
55070 _swigc__p_wxRect,
55071 _swigc__p_wxRegion,
55072 _swigc__p_wxScrollEvent,
55073 _swigc__p_wxScrollWinEvent,
55074 _swigc__p_wxSetCursorEvent,
55075 _swigc__p_wxShowEvent,
55076 _swigc__p_wxSize,
55077 _swigc__p_wxSizeEvent,
55078 _swigc__p_wxSizer,
55079 _swigc__p_wxSizerItem,
55080 _swigc__p_wxStaticBox,
55081 _swigc__p_wxStaticBoxSizer,
55082 _swigc__p_wxStdDialogButtonSizer,
55083 _swigc__p_wxSysColourChangedEvent,
55084 _swigc__p_wxTIFFHandler,
55085 _swigc__p_wxToolTip,
55086 _swigc__p_wxUpdateUIEvent,
55087 _swigc__p_wxValidator,
55088 _swigc__p_wxVisualAttributes,
55089 _swigc__p_wxWindow,
55090 _swigc__p_wxWindowCreateEvent,
55091 _swigc__p_wxWindowDestroyEvent,
55092 _swigc__p_wxXPMHandler,
55093 _swigc__p_wxZipFSHandler,
55094 };
55095
55096
55097 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55098
55099 static swig_const_info swig_const_table[] = {
55100 {0, 0, 0, 0.0, 0, 0}};
55101
55102 #ifdef __cplusplus
55103 }
55104 #endif
55105 /* -----------------------------------------------------------------------------
55106 * Type initialization:
55107 * This problem is tough by the requirement that no dynamic
55108 * memory is used. Also, since swig_type_info structures store pointers to
55109 * swig_cast_info structures and swig_cast_info structures store pointers back
55110 * to swig_type_info structures, we need some lookup code at initialization.
55111 * The idea is that swig generates all the structures that are needed.
55112 * The runtime then collects these partially filled structures.
55113 * The SWIG_InitializeModule function takes these initial arrays out of
55114 * swig_module, and does all the lookup, filling in the swig_module.types
55115 * array with the correct data and linking the correct swig_cast_info
55116 * structures together.
55117 *
55118 * The generated swig_type_info structures are assigned staticly to an initial
55119 * array. We just loop though that array, and handle each type individually.
55120 * First we lookup if this type has been already loaded, and if so, use the
55121 * loaded structure instead of the generated one. Then we have to fill in the
55122 * cast linked list. The cast data is initially stored in something like a
55123 * two-dimensional array. Each row corresponds to a type (there are the same
55124 * number of rows as there are in the swig_type_initial array). Each entry in
55125 * a column is one of the swig_cast_info structures for that type.
55126 * The cast_initial array is actually an array of arrays, because each row has
55127 * a variable number of columns. So to actually build the cast linked list,
55128 * we find the array of casts associated with the type, and loop through it
55129 * adding the casts to the list. The one last trick we need to do is making
55130 * sure the type pointer in the swig_cast_info struct is correct.
55131 *
55132 * First off, we lookup the cast->type name to see if it is already loaded.
55133 * There are three cases to handle:
55134 * 1) If the cast->type has already been loaded AND the type we are adding
55135 * casting info to has not been loaded (it is in this module), THEN we
55136 * replace the cast->type pointer with the type pointer that has already
55137 * been loaded.
55138 * 2) If BOTH types (the one we are adding casting info to, and the
55139 * cast->type) are loaded, THEN the cast info has already been loaded by
55140 * the previous module so we just ignore it.
55141 * 3) Finally, if cast->type has not already been loaded, then we add that
55142 * swig_cast_info to the linked list (because the cast->type) pointer will
55143 * be correct.
55144 * ----------------------------------------------------------------------------- */
55145
55146 #ifdef __cplusplus
55147 extern "C" {
55148 #if 0
55149 } /* c-mode */
55150 #endif
55151 #endif
55152
55153 #if 0
55154 #define SWIGRUNTIME_DEBUG
55155 #endif
55156
55157 SWIGRUNTIME void
55158 SWIG_InitializeModule(void *clientdata) {
55159 size_t i;
55160 swig_module_info *module_head;
55161 static int init_run = 0;
55162
55163 clientdata = clientdata;
55164
55165 if (init_run) return;
55166 init_run = 1;
55167
55168 /* Initialize the swig_module */
55169 swig_module.type_initial = swig_type_initial;
55170 swig_module.cast_initial = swig_cast_initial;
55171
55172 /* Try and load any already created modules */
55173 module_head = SWIG_GetModule(clientdata);
55174 if (module_head) {
55175 swig_module.next = module_head->next;
55176 module_head->next = &swig_module;
55177 } else {
55178 /* This is the first module loaded */
55179 swig_module.next = &swig_module;
55180 SWIG_SetModule(clientdata, &swig_module);
55181 }
55182
55183 /* Now work on filling in swig_module.types */
55184 #ifdef SWIGRUNTIME_DEBUG
55185 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55186 #endif
55187 for (i = 0; i < swig_module.size; ++i) {
55188 swig_type_info *type = 0;
55189 swig_type_info *ret;
55190 swig_cast_info *cast;
55191
55192 #ifdef SWIGRUNTIME_DEBUG
55193 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55194 #endif
55195
55196 /* if there is another module already loaded */
55197 if (swig_module.next != &swig_module) {
55198 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55199 }
55200 if (type) {
55201 /* Overwrite clientdata field */
55202 #ifdef SWIGRUNTIME_DEBUG
55203 printf("SWIG_InitializeModule: found type %s\n", type->name);
55204 #endif
55205 if (swig_module.type_initial[i]->clientdata) {
55206 type->clientdata = swig_module.type_initial[i]->clientdata;
55207 #ifdef SWIGRUNTIME_DEBUG
55208 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55209 #endif
55210 }
55211 } else {
55212 type = swig_module.type_initial[i];
55213 }
55214
55215 /* Insert casting types */
55216 cast = swig_module.cast_initial[i];
55217 while (cast->type) {
55218 /* Don't need to add information already in the list */
55219 ret = 0;
55220 #ifdef SWIGRUNTIME_DEBUG
55221 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55222 #endif
55223 if (swig_module.next != &swig_module) {
55224 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55225 #ifdef SWIGRUNTIME_DEBUG
55226 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55227 #endif
55228 }
55229 if (ret) {
55230 if (type == swig_module.type_initial[i]) {
55231 #ifdef SWIGRUNTIME_DEBUG
55232 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55233 #endif
55234 cast->type = ret;
55235 ret = 0;
55236 } else {
55237 /* Check for casting already in the list */
55238 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55239 #ifdef SWIGRUNTIME_DEBUG
55240 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55241 #endif
55242 if (!ocast) ret = 0;
55243 }
55244 }
55245
55246 if (!ret) {
55247 #ifdef SWIGRUNTIME_DEBUG
55248 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55249 #endif
55250 if (type->cast) {
55251 type->cast->prev = cast;
55252 cast->next = type->cast;
55253 }
55254 type->cast = cast;
55255 }
55256 cast++;
55257 }
55258 /* Set entry in modules->types array equal to the type */
55259 swig_module.types[i] = type;
55260 }
55261 swig_module.types[i] = 0;
55262
55263 #ifdef SWIGRUNTIME_DEBUG
55264 printf("**** SWIG_InitializeModule: Cast List ******\n");
55265 for (i = 0; i < swig_module.size; ++i) {
55266 int j = 0;
55267 swig_cast_info *cast = swig_module.cast_initial[i];
55268 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55269 while (cast->type) {
55270 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55271 cast++;
55272 ++j;
55273 }
55274 printf("---- Total casts: %d\n",j);
55275 }
55276 printf("**** SWIG_InitializeModule: Cast List ******\n");
55277 #endif
55278 }
55279
55280 /* This function will propagate the clientdata field of type to
55281 * any new swig_type_info structures that have been added into the list
55282 * of equivalent types. It is like calling
55283 * SWIG_TypeClientData(type, clientdata) a second time.
55284 */
55285 SWIGRUNTIME void
55286 SWIG_PropagateClientData(void) {
55287 size_t i;
55288 swig_cast_info *equiv;
55289 static int init_run = 0;
55290
55291 if (init_run) return;
55292 init_run = 1;
55293
55294 for (i = 0; i < swig_module.size; i++) {
55295 if (swig_module.types[i]->clientdata) {
55296 equiv = swig_module.types[i]->cast;
55297 while (equiv) {
55298 if (!equiv->converter) {
55299 if (equiv->type && !equiv->type->clientdata)
55300 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55301 }
55302 equiv = equiv->next;
55303 }
55304 }
55305 }
55306 }
55307
55308 #ifdef __cplusplus
55309 #if 0
55310 {
55311 /* c-mode */
55312 #endif
55313 }
55314 #endif
55315
55316
55317
55318 #ifdef __cplusplus
55319 extern "C" {
55320 #endif
55321
55322 /* Python-specific SWIG API */
55323 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55324 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55325 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55326
55327 /* -----------------------------------------------------------------------------
55328 * global variable support code.
55329 * ----------------------------------------------------------------------------- */
55330
55331 typedef struct swig_globalvar {
55332 char *name; /* Name of global variable */
55333 PyObject *(*get_attr)(void); /* Return the current value */
55334 int (*set_attr)(PyObject *); /* Set the value */
55335 struct swig_globalvar *next;
55336 } swig_globalvar;
55337
55338 typedef struct swig_varlinkobject {
55339 PyObject_HEAD
55340 swig_globalvar *vars;
55341 } swig_varlinkobject;
55342
55343 SWIGINTERN PyObject *
55344 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55345 return PyString_FromString("<Swig global variables>");
55346 }
55347
55348 SWIGINTERN PyObject *
55349 swig_varlink_str(swig_varlinkobject *v) {
55350 PyObject *str = PyString_FromString("(");
55351 swig_globalvar *var;
55352 for (var = v->vars; var; var=var->next) {
55353 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55354 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55355 }
55356 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55357 return str;
55358 }
55359
55360 SWIGINTERN int
55361 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55362 PyObject *str = swig_varlink_str(v);
55363 fprintf(fp,"Swig global variables ");
55364 fprintf(fp,"%s\n", PyString_AsString(str));
55365 Py_DECREF(str);
55366 return 0;
55367 }
55368
55369 SWIGINTERN void
55370 swig_varlink_dealloc(swig_varlinkobject *v) {
55371 swig_globalvar *var = v->vars;
55372 while (var) {
55373 swig_globalvar *n = var->next;
55374 free(var->name);
55375 free(var);
55376 var = n;
55377 }
55378 }
55379
55380 SWIGINTERN PyObject *
55381 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55382 PyObject *res = NULL;
55383 swig_globalvar *var = v->vars;
55384 while (var) {
55385 if (strcmp(var->name,n) == 0) {
55386 res = (*var->get_attr)();
55387 break;
55388 }
55389 var = var->next;
55390 }
55391 if (res == NULL && !PyErr_Occurred()) {
55392 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55393 }
55394 return res;
55395 }
55396
55397 SWIGINTERN int
55398 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55399 int res = 1;
55400 swig_globalvar *var = v->vars;
55401 while (var) {
55402 if (strcmp(var->name,n) == 0) {
55403 res = (*var->set_attr)(p);
55404 break;
55405 }
55406 var = var->next;
55407 }
55408 if (res == 1 && !PyErr_Occurred()) {
55409 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55410 }
55411 return res;
55412 }
55413
55414 SWIGINTERN PyTypeObject*
55415 swig_varlink_type(void) {
55416 static char varlink__doc__[] = "Swig var link object";
55417 static PyTypeObject varlink_type;
55418 static int type_init = 0;
55419 if (!type_init) {
55420 const PyTypeObject tmp
55421 = {
55422 PyObject_HEAD_INIT(NULL)
55423 0, /* Number of items in variable part (ob_size) */
55424 (char *)"swigvarlink", /* Type name (tp_name) */
55425 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55426 0, /* Itemsize (tp_itemsize) */
55427 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55428 (printfunc) swig_varlink_print, /* Print (tp_print) */
55429 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55430 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55431 0, /* tp_compare */
55432 (reprfunc) swig_varlink_repr, /* tp_repr */
55433 0, /* tp_as_number */
55434 0, /* tp_as_sequence */
55435 0, /* tp_as_mapping */
55436 0, /* tp_hash */
55437 0, /* tp_call */
55438 (reprfunc)swig_varlink_str, /* tp_str */
55439 0, /* tp_getattro */
55440 0, /* tp_setattro */
55441 0, /* tp_as_buffer */
55442 0, /* tp_flags */
55443 varlink__doc__, /* tp_doc */
55444 0, /* tp_traverse */
55445 0, /* tp_clear */
55446 0, /* tp_richcompare */
55447 0, /* tp_weaklistoffset */
55448 #if PY_VERSION_HEX >= 0x02020000
55449 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55450 #endif
55451 #if PY_VERSION_HEX >= 0x02030000
55452 0, /* tp_del */
55453 #endif
55454 #ifdef COUNT_ALLOCS
55455 0,0,0,0 /* tp_alloc -> tp_next */
55456 #endif
55457 };
55458 varlink_type = tmp;
55459 varlink_type.ob_type = &PyType_Type;
55460 type_init = 1;
55461 }
55462 return &varlink_type;
55463 }
55464
55465 /* Create a variable linking object for use later */
55466 SWIGINTERN PyObject *
55467 SWIG_Python_newvarlink(void) {
55468 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55469 if (result) {
55470 result->vars = 0;
55471 }
55472 return ((PyObject*) result);
55473 }
55474
55475 SWIGINTERN void
55476 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55477 swig_varlinkobject *v = (swig_varlinkobject *) p;
55478 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55479 if (gv) {
55480 size_t size = strlen(name)+1;
55481 gv->name = (char *)malloc(size);
55482 if (gv->name) {
55483 strncpy(gv->name,name,size);
55484 gv->get_attr = get_attr;
55485 gv->set_attr = set_attr;
55486 gv->next = v->vars;
55487 }
55488 }
55489 v->vars = gv;
55490 }
55491
55492 SWIGINTERN PyObject *
55493 SWIG_globals() {
55494 static PyObject *_SWIG_globals = 0;
55495 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55496 return _SWIG_globals;
55497 }
55498
55499 /* -----------------------------------------------------------------------------
55500 * constants/methods manipulation
55501 * ----------------------------------------------------------------------------- */
55502
55503 /* Install Constants */
55504 SWIGINTERN void
55505 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55506 PyObject *obj = 0;
55507 size_t i;
55508 for (i = 0; constants[i].type; ++i) {
55509 switch(constants[i].type) {
55510 case SWIG_PY_POINTER:
55511 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55512 break;
55513 case SWIG_PY_BINARY:
55514 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55515 break;
55516 default:
55517 obj = 0;
55518 break;
55519 }
55520 if (obj) {
55521 PyDict_SetItemString(d, constants[i].name, obj);
55522 Py_DECREF(obj);
55523 }
55524 }
55525 }
55526
55527 /* -----------------------------------------------------------------------------*/
55528 /* Fix SwigMethods to carry the callback ptrs when needed */
55529 /* -----------------------------------------------------------------------------*/
55530
55531 SWIGINTERN void
55532 SWIG_Python_FixMethods(PyMethodDef *methods,
55533 swig_const_info *const_table,
55534 swig_type_info **types,
55535 swig_type_info **types_initial) {
55536 size_t i;
55537 for (i = 0; methods[i].ml_name; ++i) {
55538 char *c = methods[i].ml_doc;
55539 if (c && (c = strstr(c, "swig_ptr: "))) {
55540 int j;
55541 swig_const_info *ci = 0;
55542 char *name = c + 10;
55543 for (j = 0; const_table[j].type; ++j) {
55544 if (strncmp(const_table[j].name, name,
55545 strlen(const_table[j].name)) == 0) {
55546 ci = &(const_table[j]);
55547 break;
55548 }
55549 }
55550 if (ci) {
55551 size_t shift = (ci->ptype) - types;
55552 swig_type_info *ty = types_initial[shift];
55553 size_t ldoc = (c - methods[i].ml_doc);
55554 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55555 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55556 if (ndoc) {
55557 char *buff = ndoc;
55558 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55559 if (ptr) {
55560 strncpy(buff, methods[i].ml_doc, ldoc);
55561 buff += ldoc;
55562 strncpy(buff, "swig_ptr: ", 10);
55563 buff += 10;
55564 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55565 methods[i].ml_doc = ndoc;
55566 }
55567 }
55568 }
55569 }
55570 }
55571 }
55572
55573 #ifdef __cplusplus
55574 }
55575 #endif
55576
55577 /* -----------------------------------------------------------------------------*
55578 * Partial Init method
55579 * -----------------------------------------------------------------------------*/
55580
55581 #ifdef __cplusplus
55582 extern "C"
55583 #endif
55584 SWIGEXPORT void SWIG_init(void) {
55585 PyObject *m, *d;
55586
55587 /* Fix SwigMethods to carry the callback ptrs when needed */
55588 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55589
55590 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55591 d = PyModule_GetDict(m);
55592
55593 SWIG_InitializeModule(0);
55594 SWIG_InstallConstants(d,swig_const_table);
55595
55596
55597
55598 #ifndef wxPyUSE_EXPORT
55599 // Make our API structure a CObject so other modules can import it
55600 // from this module.
55601 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55602 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55603 Py_XDECREF(cobj);
55604 #endif
55605
55606 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55607 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55608 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55609 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55610 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55611 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55612 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55613 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55614 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55615 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55616 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55617 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55618 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55619 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55620 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55621 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55622 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55623 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55624 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55625 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55626 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55627 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55628 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55629 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55630 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55631 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55632 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55633 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55634 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55635 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55636 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55637 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55638 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55639 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55640 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55641 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55642 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55643 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55644 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55645 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55646 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55647 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55648 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55649 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55650 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55651 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55652 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55653 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55654 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55655 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55656 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55657 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55658 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55659 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55660 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55661 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55662 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55663 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55664 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55665 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55666 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55667 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55668 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55669 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55670 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55671 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55672 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55673 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55674 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55675 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55676 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55677 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55678 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55679 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55680 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55681 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55682 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55683 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55684 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55685 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55686 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55687 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55688 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55689 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55690 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55691 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55692 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55693 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55694 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55695 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55696 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55697 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55698 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55699 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55700 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55701 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55702 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55703 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55704 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55705 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55706 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55707 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55708 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55709 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55710 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55711 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55712 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55713 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55714 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55715 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55716 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55717 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55718 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55719 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55720 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55721 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55722 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55723 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55724 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55725 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55726 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55727 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55728 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55729 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55730 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55731 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55732 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55733 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55734 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55735 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55736 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55737 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55738 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55739 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55740 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55741 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55742 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55743 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55744 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55745 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55746 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55747 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55748 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55749 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55750 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55751 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55752 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55753 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55754 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55755 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55756 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55757 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55758 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55759 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55760 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55761 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55762 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55763 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55764 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55765 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55766 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55767 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55768 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55769 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55770 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55771 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55772 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55773 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55774 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55775 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55776 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55777 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55778 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55779 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55780 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55781 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55782 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55783 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55784 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55785 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55786 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55787 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55788 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55789 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55790 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55791 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55792 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55793 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55794 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55795 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55796 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55797 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55798 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55799 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55800 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55801 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55802 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55803 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55804 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55805 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55806 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55807 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55808 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55809 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55810 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55811 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55812 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55813 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55814 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55815 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55816 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55817 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55818 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55819 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55820 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55821 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55822 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55823 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55824 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55825 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55826 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55827 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55828 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55829 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55830 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55831 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55832 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55833 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55834 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55835 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55836 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55837 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55838 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55839 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55840 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55841 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55842 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55843 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55844 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55845 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55846 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55847 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55848 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55849 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55850 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55851 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55852 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55853 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55854 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55855 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55856 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55857 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55858 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55859 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55860 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55861 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55862 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55863 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55864 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55865 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55866 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55867 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55868 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55869 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55870 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55871 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55872 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55873 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55874 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55875 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55876 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55877 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55878 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55879 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55880 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55881 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55882 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55883 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55884 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55885 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55886 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55887 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55888 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55889 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55890 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55891 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55892 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55893 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55894 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55895 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55896 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55897 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55898 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55899 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55900 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55901 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55902 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55903 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55904 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55905 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55906 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55907 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55908 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55909 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55910 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55911 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55912 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55913 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55914 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55915 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55916 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55917 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55918 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55919 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55920 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55921 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55922 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55923 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55924 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55925 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55926 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55927 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55928 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55929 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55930 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55931 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55932 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55933 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55934 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55935 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55936 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55937 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55938 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55939 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55940 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55941 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55942 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55943 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55944 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55945 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55946 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55947 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55948 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55949 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55950 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55951 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55952 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55953 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55954 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55955 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55956 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55957 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55958 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55959 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55960 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55961 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55962 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55963 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55964 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55965 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55966 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55967 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55968 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55969 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55970 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55971 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55972 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55973 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55974 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55975 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55976 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55977 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55978 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55979 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55980 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55981 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55982 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55983 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55984 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55985 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55986 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55987 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55988 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55989 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55990 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55991 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55992 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55993 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55994 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55995 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55996 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55997 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55998 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55999 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56000 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56001 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56002 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56003 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56004 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56005 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56012 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56013 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56014 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56015 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56016 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56017 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56018 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56019 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56020 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56021 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56022 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56023 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56024 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56025 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56026 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56027 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56028 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56029 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56030 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56031 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56032 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56033 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56034 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56035 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56036 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56037 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56038 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56039 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56040 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56041 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56042 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56043 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56044 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56045 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56046 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56047 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56048 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56049 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56050 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56051 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56052 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56053 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56054 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56055 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56056 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56057 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56058 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56059 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56060 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56061 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56062 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56063 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56064 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56065 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56066 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56067 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56068 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56069 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56070 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56071 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56072 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56073 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56074 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56075 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56076 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56077 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56078 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56079 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56080 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56081 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56082 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56083 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56084 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56085 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56086 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56087 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56088 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56089 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56090 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56091 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56092 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56093 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56094 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56095 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56096 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56097 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56098 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56099 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56100 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56101 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56102 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56103 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56104 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56105 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56106 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56107 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56108 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56109 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56110 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56111 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56112 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56113 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56114 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56115 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56116 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56117 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56118 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56119 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56120 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56121 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56122 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56123 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56124 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56125 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56126 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56127 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56128 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56129 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56130 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56131 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56132 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56133 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56134 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56135 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56136 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56137 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56138 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56139 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56140 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56141 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56142 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56143 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56144 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56145 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56146 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56147 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56148 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56149 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56150 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56151 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56152 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56153 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56154 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56155 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56156 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56157 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56158 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56159 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56160 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56161 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56162 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56163 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56164 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56165 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56166 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56167 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56168 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56169 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56170 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56171 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56172 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56173 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56174 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56175 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56176 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56177 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56178 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56179 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56180 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56181 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56182 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56183 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56184 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56185 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56186 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56187 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56188 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56189 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56190 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56191 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56192 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56193 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56194 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56195 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56196 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56197 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56198 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56199 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56200 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56201 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56202 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56203 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56204 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56205 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56206 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56207 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56208 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56209 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56210 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56211 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56215 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56216 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56217 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56218 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56219 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56220 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56221 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56222 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56223 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56224 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56225 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56226 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56227 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56228 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56229 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56230 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56231 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56232 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56233 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56234 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56235 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56236 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56237 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56238 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56239 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56240 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56241 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56242 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56243 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56244 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56245 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56246 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56247 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56248 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56249 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56250 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56251 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56252 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56253 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56254 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56255 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56256 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56257 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56258 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56259 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56260 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56261 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56262 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56263 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56264 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56265 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56266 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56267 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56268
56269 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56270
56271
56272 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56273
56274 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56275 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56276 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56277 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56278 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56279 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56280 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56281 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56282 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56283 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56285 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56286 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56287 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56288 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56289 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56290 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56291 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56292 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56293 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56294 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56295 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56296 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56297 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56298 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56299 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56300 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56301 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56302 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56303 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56304 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56305 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56306 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56307 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56308 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56309 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56310 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56311 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56312 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56313 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56314 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56315 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56316 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56317 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56318 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56319 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56320 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56321 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56322 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56323 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56324 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56325 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56326 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56327 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56328 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56329 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56330 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56331 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56332 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56333 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56334 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56335 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56336 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56337 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56338 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56339 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56340 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56341 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56342 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56343 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56344 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56345 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56346 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56347 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56348 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56349 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56350 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56351 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56352 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56353 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56354 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56355 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56356 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56357 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56358 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56359 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56360 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56361 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56362 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56363 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56364 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56365 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56366 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56367 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56368 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56369 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56370 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56371 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56372 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56373 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56374 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56375 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56376 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56377 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56378 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56379 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56380 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56381 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56382 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56383 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56384 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56385 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56386 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56387 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56388 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56389 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56390 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56391 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56392 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56393 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56394 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56395 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56396 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56397 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56398 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56399 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56400 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56401 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56402 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56403 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56404 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56405 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56406 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56407 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56408 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56409 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56410 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56411 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56412 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56413 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56414 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56415 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56416 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56417 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56418 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56419 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56420 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56421 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56422 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56423 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56424 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56425 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56426 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56427 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56428 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56429 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56430 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56431 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56432 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56433 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56434 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56435 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56436 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56437 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56438 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56439 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56440 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56441 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56442 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56443 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56444 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56445 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56446 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56447 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56448 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56449 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56450 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56451 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56452 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56453 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56454 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56455 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56456 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56457 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56458 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56459 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56460 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56461 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56462 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56463 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56464 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56465 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56466 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56467 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56468 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56469 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56470 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56471 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56472 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56473 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56474 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56475 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56476 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56477 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56478 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56479 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56480
56481 // Initialize threading, some globals and such
56482 __wxPyPreStart(d);
56483
56484
56485 // Although these are defined in __version__ they need to be here too so
56486 // that an assert can be done to ensure that the wxPython and the wxWindows
56487 // versions match.
56488 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56489 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56490 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56491
56492 }
56493
wxWidgets (Impactor)