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


6d1c4a09148edc32041c56f8231bdbf22d22885f
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3934 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3935 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3936 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3937 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3938 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3940 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3941 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3942 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3943 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3944 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3945 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3946 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3947 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3948 static const wxString wxPyControlNameStr(wxControlNameStr);
3949 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3950 if (clientData) {
3951 wxPyClientData* data = new wxPyClientData(clientData);
3952 return self->Append(item, data);
3953 } else
3954 return self->Append(item);
3955 }
3956 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3957 if (clientData) {
3958 wxPyClientData* data = new wxPyClientData(clientData);
3959 return self->Insert(item, pos, data);
3960 } else
3961 return self->Insert(item, pos);
3962 }
3963 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3964 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3965 if (data) {
3966 Py_INCREF(data->m_obj);
3967 return data->m_obj;
3968 } else {
3969 Py_INCREF(Py_None);
3970 return Py_None;
3971 }
3972 }
3973 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3974 wxPyClientData* data = new wxPyClientData(clientData);
3975 self->SetClientObject(n, data);
3976 }
3977
3978
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(window, proportion, flag, border, data);
3987 }
3988 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 return new wxSizerItem(width, height, proportion, flag, border, data);
3996 }
3997 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3998 wxPyUserData* data = NULL;
3999 if ( userData ) {
4000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4001 data = new wxPyUserData(userData);
4002 wxPyEndBlockThreads(blocked);
4003 }
4004 return new wxSizerItem(sizer, proportion, flag, border, data);
4005 }
4006
4007 SWIGINTERNINLINE PyObject *
4008 SWIG_From_float (float value)
4009 {
4010 return SWIG_From_double (value);
4011 }
4012
4013 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4014 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 self->SetUserData(data);
4031 }
4032
4033 // Figure out the type of the sizer item
4034
4035 struct wxPySizerItemInfo {
4036 wxPySizerItemInfo()
4037 : window(NULL), sizer(NULL), gotSize(false),
4038 size(wxDefaultSize), gotPos(false), pos(-1)
4039 {}
4040
4041 wxWindow* window;
4042 wxSizer* sizer;
4043 bool gotSize;
4044 wxSize size;
4045 bool gotPos;
4046 int pos;
4047 };
4048
4049 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4050
4051 wxPySizerItemInfo info;
4052 wxSize size;
4053 wxSize* sizePtr = &size;
4054
4055 // Find out what the type of the item is
4056 // try wxWindow
4057 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4058 PyErr_Clear();
4059 info.window = NULL;
4060
4061 // try wxSizer
4062 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4063 PyErr_Clear();
4064 info.sizer = NULL;
4065
4066 // try wxSize or (w,h)
4067 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4068 info.size = *sizePtr;
4069 info.gotSize = true;
4070 }
4071
4072 // or a single int
4073 if (checkIdx && PyInt_Check(item)) {
4074 info.pos = PyInt_AsLong(item);
4075 info.gotPos = true;
4076 }
4077 }
4078 }
4079
4080 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4081 // no expected type, figure out what kind of error message to generate
4082 if ( !checkSize && !checkIdx )
4083 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4084 else if ( checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4086 else if ( !checkSize && checkIdx)
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4088 else
4089 // can this one happen?
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4091 }
4092
4093 return info;
4094 }
4095
4096 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4097 if (!self->GetClientObject())
4098 self->SetClientObject(new wxPyOORClientData(_self));
4099 }
4100 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4101
4102 wxPyUserData* data = NULL;
4103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4105 if ( userData && (info.window || info.sizer || info.gotSize) )
4106 data = new wxPyUserData(userData);
4107 if ( info.sizer )
4108 PyObject_SetAttrString(item,"thisown",Py_False);
4109 wxPyEndBlockThreads(blocked);
4110
4111 // Now call the real Add method if a valid item type was found
4112 if ( info.window )
4113 return self->Add(info.window, proportion, flag, border, data);
4114 else if ( info.sizer )
4115 return self->Add(info.sizer, proportion, flag, border, data);
4116 else if (info.gotSize)
4117 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4118 proportion, flag, border, data);
4119 else
4120 return NULL;
4121 }
4122 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4123
4124 wxPyUserData* data = NULL;
4125 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4126 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4127 if ( userData && (info.window || info.sizer || info.gotSize) )
4128 data = new wxPyUserData(userData);
4129 if ( info.sizer )
4130 PyObject_SetAttrString(item,"thisown",Py_False);
4131 wxPyEndBlockThreads(blocked);
4132
4133 // Now call the real Insert method if a valid item type was found
4134 if ( info.window )
4135 return self->Insert(before, info.window, proportion, flag, border, data);
4136 else if ( info.sizer )
4137 return self->Insert(before, info.sizer, proportion, flag, border, data);
4138 else if (info.gotSize)
4139 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4140 proportion, flag, border, data);
4141 else
4142 return NULL;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Prepend method if a valid item type was found
4156 if ( info.window )
4157 return self->Prepend(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Prepend(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Remove(info.window);
4172 else if ( info.sizer )
4173 return self->Remove(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Remove(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->Detach(info.window);
4185 else if ( info.sizer )
4186 return self->Detach(info.sizer);
4187 else if ( info.gotPos )
4188 return self->Detach(info.pos);
4189 else
4190 return false;
4191 }
4192 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 return self->GetItem(info.window);
4198 else if ( info.sizer )
4199 return self->GetItem(info.sizer);
4200 else if ( info.gotPos )
4201 return self->GetItem(info.pos);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 self->SetItemMinSize(info.window, size);
4211 else if ( info.sizer )
4212 self->SetItemMinSize(info.sizer, size);
4213 else if ( info.gotPos )
4214 self->SetItemMinSize(info.pos, size);
4215 }
4216 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4217 wxSizerItemList& list = self->GetChildren();
4218 return wxPy_ConvertList(&list);
4219 }
4220 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Show(info.window, show, recursive);
4226 else if ( info.sizer )
4227 return self->Show(info.sizer, show, recursive);
4228 else if ( info.gotPos )
4229 return self->Show(info.pos, show);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->IsShown(info.window);
4239 else if ( info.sizer )
4240 return self->IsShown(info.sizer);
4241 else if ( info.gotPos )
4242 return self->IsShown(info.pos);
4243 else
4244 return false;
4245 }
4246
4247 // See pyclasses.h
4248 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4249 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4250 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4251
4252
4253
4254
4255 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4256 {
4257 if (source == Py_None) {
4258 **obj = wxGBPosition(-1,-1);
4259 return true;
4260 }
4261 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4262 }
4263
4264 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4265 {
4266 if (source == Py_None) {
4267 **obj = wxGBSpan(-1,-1);
4268 return true;
4269 }
4270 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4271 }
4272
4273
4274 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4275 wxGBPosition temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBPosition_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4284 wxGBPosition temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBPosition_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4293 self->SetRow(row);
4294 self->SetCol(col);
4295 }
4296 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4305 wxGBSpan temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBSpan_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4314 wxGBSpan temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBSpan_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4323 self->SetRowspan(rowspan);
4324 self->SetColspan(colspan);
4325 }
4326 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(window, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4344 wxPyUserData* data = NULL;
4345 if ( userData ) {
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 data = new wxPyUserData(userData);
4348 wxPyEndBlockThreads(blocked);
4349 }
4350 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4351 }
4352 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4353 wxPyUserData* data = NULL;
4354 if ( userData ) {
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 data = new wxPyUserData(userData);
4357 wxPyEndBlockThreads(blocked);
4358 }
4359 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4360 }
4361 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4362 int row, col;
4363 self->GetEndPos(row, col);
4364 return wxGBPosition(row, col);
4365 }
4366 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4367
4368 wxPyUserData* data = NULL;
4369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4371 if ( userData && (info.window || info.sizer || info.gotSize) )
4372 data = new wxPyUserData(userData);
4373 if ( info.sizer )
4374 PyObject_SetAttrString(item,"thisown",Py_False);
4375 wxPyEndBlockThreads(blocked);
4376
4377 // Now call the real Add method if a valid item type was found
4378 if ( info.window )
4379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4380 else if ( info.sizer )
4381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4382 else if (info.gotSize)
4383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4384 pos, span, flag, border, data);
4385 return NULL;
4386 }
4387
4388
4389 #ifdef __cplusplus
4390 extern "C" {
4391 #endif
4392 SWIGINTERN int EmptyString_set(PyObject *) {
4393 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4394 return 1;
4395 }
4396
4397
4398 SWIGINTERN PyObject *EmptyString_get(void) {
4399 PyObject *pyobj = 0;
4400
4401 {
4402 #if wxUSE_UNICODE
4403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4404 #else
4405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #endif
4407 }
4408 return pyobj;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 wxString result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = wxObject_GetClassName(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 {
4434 #if wxUSE_UNICODE
4435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4436 #else
4437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4438 #endif
4439 }
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxObject *arg1 = (wxObject *) 0 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 PyObject *swig_obj[1] ;
4452
4453 if (!args) SWIG_fail;
4454 swig_obj[0] = args;
4455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4458 }
4459 arg1 = reinterpret_cast< wxObject * >(argp1);
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 wxObject_Destroy(arg1);
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_Py_Void();
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474 PyObject *obj;
4475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4476 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4477 return SWIG_Py_Void();
4478 }
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int arg2 ;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 int val2 ;
4487 int ecode2 = 0 ;
4488 PyObject *swig_obj[2] ;
4489
4490 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4497 if (!SWIG_IsOK(ecode2)) {
4498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4499 }
4500 arg2 = static_cast< int >(val2);
4501 if (arg1) (arg1)->x = arg2;
4502
4503 resultobj = SWIG_Py_Void();
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int result;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject *swig_obj[1] ;
4517
4518 if (!args) SWIG_fail;
4519 swig_obj[0] = args;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 result = (int) ((arg1)->x);
4526 resultobj = SWIG_From_int(static_cast< int >(result));
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int arg2 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 int val2 ;
4540 int ecode2 = 0 ;
4541 PyObject *swig_obj[2] ;
4542
4543 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4550 if (!SWIG_IsOK(ecode2)) {
4551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4552 }
4553 arg2 = static_cast< int >(val2);
4554 if (arg1) (arg1)->y = arg2;
4555
4556 resultobj = SWIG_Py_Void();
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *resultobj = 0;
4565 wxSize *arg1 = (wxSize *) 0 ;
4566 int result;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4576 }
4577 arg1 = reinterpret_cast< wxSize * >(argp1);
4578 result = (int) ((arg1)->y);
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 int arg1 = (int) 0 ;
4589 int arg2 = (int) 0 ;
4590 wxSize *result = 0 ;
4591 int val1 ;
4592 int ecode1 = 0 ;
4593 int val2 ;
4594 int ecode2 = 0 ;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "w",(char *) "h", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4602 if (obj0) {
4603 ecode1 = SWIG_AsVal_int(obj0, &val1);
4604 if (!SWIG_IsOK(ecode1)) {
4605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4606 }
4607 arg1 = static_cast< int >(val1);
4608 }
4609 if (obj1) {
4610 ecode2 = SWIG_AsVal_int(obj1, &val2);
4611 if (!SWIG_IsOK(ecode2)) {
4612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4613 }
4614 arg2 = static_cast< int >(val2);
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxSize *)new wxSize(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *resultobj = 0;
4631 wxSize *arg1 = (wxSize *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject *swig_obj[1] ;
4635
4636 if (!args) SWIG_fail;
4637 swig_obj[0] = args;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 delete arg1;
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___eq__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 PyObject *arg2 = (PyObject *) 0 ;
4694 bool result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "other", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 arg2 = obj1;
4710 {
4711 result = (bool)wxSize___ne__(arg1,arg2);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 wxSize *arg1 = (wxSize *) 0 ;
4726 wxSize *arg2 = 0 ;
4727 wxSize result;
4728 void *argp1 = 0 ;
4729 int res1 = 0 ;
4730 wxSize temp2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "self",(char *) "sz", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4741 }
4742 arg1 = reinterpret_cast< wxSize * >(argp1);
4743 {
4744 arg2 = &temp2;
4745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (arg1)->operator +((wxSize const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (arg1)->operator -((wxSize const &)*arg2);
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 wxSize *arg2 = 0 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 wxSize temp2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "self",(char *) "sz", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4812 if (!SWIG_IsOK(res1)) {
4813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4814 }
4815 arg1 = reinterpret_cast< wxSize * >(argp1);
4816 {
4817 arg2 = &temp2;
4818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 (arg1)->IncTo((wxSize const &)*arg2);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_Py_Void();
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 wxSize *arg2 = 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 wxSize temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "sz", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->DecTo((wxSize const &)*arg2);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 float arg2 ;
4873 float arg3 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 float val2 ;
4877 int ecode2 = 0 ;
4878 float val3 ;
4879 int ecode3 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 PyObject * obj2 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 ecode2 = SWIG_AsVal_float(obj1, &val2);
4894 if (!SWIG_IsOK(ecode2)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4896 }
4897 arg2 = static_cast< float >(val2);
4898 ecode3 = SWIG_AsVal_float(obj2, &val3);
4899 if (!SWIG_IsOK(ecode3)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4901 }
4902 arg3 = static_cast< float >(val3);
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 (arg1)->Scale(arg2,arg3);
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_Py_Void();
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 int arg2 ;
4920 int arg3 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 int val2 ;
4924 int ecode2 = 0 ;
4925 int val3 ;
4926 int ecode3 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 PyObject * obj2 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "self",(char *) "w",(char *) "h", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4936 if (!SWIG_IsOK(res1)) {
4937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4938 }
4939 arg1 = reinterpret_cast< wxSize * >(argp1);
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 ecode3 = SWIG_AsVal_int(obj2, &val3);
4946 if (!SWIG_IsOK(ecode3)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4948 }
4949 arg3 = static_cast< int >(val3);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->Set(arg2,arg3);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int arg2 ;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 int val2 ;
4970 int ecode2 = 0 ;
4971 PyObject * obj0 = 0 ;
4972 PyObject * obj1 = 0 ;
4973 char * kwnames[] = {
4974 (char *) "self",(char *) "w", NULL
4975 };
4976
4977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 ecode2 = SWIG_AsVal_int(obj1, &val2);
4984 if (!SWIG_IsOK(ecode2)) {
4985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4986 }
4987 arg2 = static_cast< int >(val2);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 (arg1)->SetWidth(arg2);
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_Py_Void();
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 int arg2 ;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 int val2 ;
5008 int ecode2 = 0 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetHeight(arg2);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_Py_Void();
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 int result;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 PyObject *swig_obj[1] ;
5046
5047 if (!args) SWIG_fail;
5048 swig_obj[0] = args;
5049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5050 if (!SWIG_IsOK(res1)) {
5051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5052 }
5053 arg1 = reinterpret_cast< wxSize * >(argp1);
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (int)((wxSize const *)arg1)->GetWidth();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_From_int(static_cast< int >(result));
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 wxSize *arg1 = (wxSize *) 0 ;
5070 int result;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 PyObject *swig_obj[1] ;
5074
5075 if (!args) SWIG_fail;
5076 swig_obj[0] = args;
5077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (int)((wxSize const *)arg1)->GetHeight();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_From_int(static_cast< int >(result));
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 bool result;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 PyObject *swig_obj[1] ;
5102
5103 if (!args) SWIG_fail;
5104 swig_obj[0] = args;
5105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 wxSize *arg2 = 0 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 wxSize temp2 ;
5132 PyObject * obj0 = 0 ;
5133 PyObject * obj1 = 0 ;
5134 char * kwnames[] = {
5135 (char *) "self",(char *) "size", NULL
5136 };
5137
5138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5140 if (!SWIG_IsOK(res1)) {
5141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5142 }
5143 arg1 = reinterpret_cast< wxSize * >(argp1);
5144 {
5145 arg2 = &temp2;
5146 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5147 }
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 (arg1)->SetDefaults((wxSize const &)*arg2);
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 PyObject *result = 0 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 PyObject *swig_obj[1] ;
5168
5169 if (!args) SWIG_fail;
5170 swig_obj[0] = args;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5174 }
5175 arg1 = reinterpret_cast< wxSize * >(argp1);
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 result = (PyObject *)wxSize_Get(arg1);
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 resultobj = result;
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *obj;
5191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5192 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5193 return SWIG_Py_Void();
5194 }
5195
5196 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 return SWIG_Python_InitShadowInstance(args);
5198 }
5199
5200 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5201 PyObject *resultobj = 0;
5202 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5203 double arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 double val2 ;
5207 int ecode2 = 0 ;
5208 PyObject *swig_obj[2] ;
5209
5210 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5217 if (!SWIG_IsOK(ecode2)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5219 }
5220 arg2 = static_cast< double >(val2);
5221 if (arg1) (arg1)->x = arg2;
5222
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5231 PyObject *resultobj = 0;
5232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5233 double result;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 PyObject *swig_obj[1] ;
5237
5238 if (!args) SWIG_fail;
5239 swig_obj[0] = args;
5240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5243 }
5244 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5245 result = (double) ((arg1)->x);
5246 resultobj = SWIG_From_double(static_cast< double >(result));
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5254 PyObject *resultobj = 0;
5255 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5256 double arg2 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 double val2 ;
5260 int ecode2 = 0 ;
5261 PyObject *swig_obj[2] ;
5262
5263 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5265 if (!SWIG_IsOK(res1)) {
5266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5267 }
5268 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5269 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5270 if (!SWIG_IsOK(ecode2)) {
5271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5272 }
5273 arg2 = static_cast< double >(val2);
5274 if (arg1) (arg1)->y = arg2;
5275
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 double result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject *swig_obj[1] ;
5290
5291 if (!args) SWIG_fail;
5292 swig_obj[0] = args;
5293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5294 if (!SWIG_IsOK(res1)) {
5295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5296 }
5297 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5298 result = (double) ((arg1)->y);
5299 resultobj = SWIG_From_double(static_cast< double >(result));
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 double arg1 = (double) 0.0 ;
5309 double arg2 = (double) 0.0 ;
5310 wxRealPoint *result = 0 ;
5311 double val1 ;
5312 int ecode1 = 0 ;
5313 double val2 ;
5314 int ecode2 = 0 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char * kwnames[] = {
5318 (char *) "x",(char *) "y", NULL
5319 };
5320
5321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5322 if (obj0) {
5323 ecode1 = SWIG_AsVal_double(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5326 }
5327 arg1 = static_cast< double >(val1);
5328 }
5329 if (obj1) {
5330 ecode2 = SWIG_AsVal_double(obj1, &val2);
5331 if (!SWIG_IsOK(ecode2)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5333 }
5334 arg2 = static_cast< double >(val2);
5335 }
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 PyObject *swig_obj[1] ;
5355
5356 if (!args) SWIG_fail;
5357 swig_obj[0] = args;
5358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 delete arg1;
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 resultobj = SWIG_Py_Void();
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 PyObject *arg2 = (PyObject *) 0 ;
5381 bool result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "other", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5392 if (!SWIG_IsOK(res1)) {
5393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 arg2 = obj1;
5397 {
5398 result = (bool)wxRealPoint___eq__(arg1,arg2);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 PyObject *arg2 = (PyObject *) 0 ;
5414 bool result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "other", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 arg2 = obj1;
5430 {
5431 result = (bool)wxRealPoint___ne__(arg1,arg2);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5436 }
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj = 0;
5445 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5446 wxRealPoint *arg2 = 0 ;
5447 wxRealPoint result;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 wxRealPoint temp2 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "pt", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 {
5464 arg2 = &temp2;
5465 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5466 }
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 wxRealPoint *arg2 = 0 ;
5484 wxRealPoint result;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 wxRealPoint temp2 ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 char * kwnames[] = {
5491 (char *) "self",(char *) "pt", NULL
5492 };
5493
5494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5496 if (!SWIG_IsOK(res1)) {
5497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5498 }
5499 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5500 {
5501 arg2 = &temp2;
5502 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5520 double arg2 ;
5521 double arg3 ;
5522 void *argp1 = 0 ;
5523 int res1 = 0 ;
5524 double val2 ;
5525 int ecode2 = 0 ;
5526 double val3 ;
5527 int ecode3 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "x",(char *) "y", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_double(obj1, &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5544 }
5545 arg2 = static_cast< double >(val2);
5546 ecode3 = SWIG_AsVal_double(obj2, &val3);
5547 if (!SWIG_IsOK(ecode3)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5549 }
5550 arg3 = static_cast< double >(val3);
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 wxRealPoint_Set(arg1,arg2,arg3);
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 resultobj = SWIG_Py_Void();
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5567 PyObject *result = 0 ;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 PyObject *swig_obj[1] ;
5571
5572 if (!args) SWIG_fail;
5573 swig_obj[0] = args;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (PyObject *)wxRealPoint_Get(arg1);
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = result;
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *obj;
5594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5595 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5596 return SWIG_Py_Void();
5597 }
5598
5599 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 return SWIG_Python_InitShadowInstance(args);
5601 }
5602
5603 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5604 PyObject *resultobj = 0;
5605 wxPoint *arg1 = (wxPoint *) 0 ;
5606 int arg2 ;
5607 void *argp1 = 0 ;
5608 int res1 = 0 ;
5609 int val2 ;
5610 int ecode2 = 0 ;
5611 PyObject *swig_obj[2] ;
5612
5613 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5620 if (!SWIG_IsOK(ecode2)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5622 }
5623 arg2 = static_cast< int >(val2);
5624 if (arg1) (arg1)->x = arg2;
5625
5626 resultobj = SWIG_Py_Void();
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 PyObject *resultobj = 0;
5635 wxPoint *arg1 = (wxPoint *) 0 ;
5636 int result;
5637 void *argp1 = 0 ;
5638 int res1 = 0 ;
5639 PyObject *swig_obj[1] ;
5640
5641 if (!args) SWIG_fail;
5642 swig_obj[0] = args;
5643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxPoint * >(argp1);
5648 result = (int) ((arg1)->x);
5649 resultobj = SWIG_From_int(static_cast< int >(result));
5650 return resultobj;
5651 fail:
5652 return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5657 PyObject *resultobj = 0;
5658 wxPoint *arg1 = (wxPoint *) 0 ;
5659 int arg2 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 int val2 ;
5663 int ecode2 = 0 ;
5664 PyObject *swig_obj[2] ;
5665
5666 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5670 }
5671 arg1 = reinterpret_cast< wxPoint * >(argp1);
5672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5673 if (!SWIG_IsOK(ecode2)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5675 }
5676 arg2 = static_cast< int >(val2);
5677 if (arg1) (arg1)->y = arg2;
5678
5679 resultobj = SWIG_Py_Void();
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 int result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject *swig_obj[1] ;
5693
5694 if (!args) SWIG_fail;
5695 swig_obj[0] = args;
5696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxPoint * >(argp1);
5701 result = (int) ((arg1)->y);
5702 resultobj = SWIG_From_int(static_cast< int >(result));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 int arg1 = (int) 0 ;
5712 int arg2 = (int) 0 ;
5713 wxPoint *result = 0 ;
5714 int val1 ;
5715 int ecode1 = 0 ;
5716 int val2 ;
5717 int ecode2 = 0 ;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 char * kwnames[] = {
5721 (char *) "x",(char *) "y", NULL
5722 };
5723
5724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5725 if (obj0) {
5726 ecode1 = SWIG_AsVal_int(obj0, &val1);
5727 if (!SWIG_IsOK(ecode1)) {
5728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5729 }
5730 arg1 = static_cast< int >(val1);
5731 }
5732 if (obj1) {
5733 ecode2 = SWIG_AsVal_int(obj1, &val2);
5734 if (!SWIG_IsOK(ecode2)) {
5735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5736 }
5737 arg2 = static_cast< int >(val2);
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (wxPoint *)new wxPoint(arg1,arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 PyObject *swig_obj[1] ;
5758
5759 if (!args) SWIG_fail;
5760 swig_obj[0] = args;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 delete arg1;
5769
5770 wxPyEndAllowThreads(__tstate);
5771 if (PyErr_Occurred()) SWIG_fail;
5772 }
5773 resultobj = SWIG_Py_Void();
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 PyObject *arg2 = (PyObject *) 0 ;
5784 bool result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "other", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 arg2 = obj1;
5800 {
5801 result = (bool)wxPoint___eq__(arg1,arg2);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 {
5805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5806 }
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 PyObject *arg2 = (PyObject *) 0 ;
5817 bool result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "other", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 arg2 = obj1;
5833 {
5834 result = (bool)wxPoint___ne__(arg1,arg2);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxPoint *arg1 = (wxPoint *) 0 ;
5849 wxPoint *arg2 = 0 ;
5850 wxPoint result;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 wxPoint temp2 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "self",(char *) "pt", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 {
5867 arg2 = &temp2;
5868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5869 }
5870 {
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 result = (arg1)->operator +((wxPoint const &)*arg2);
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint result;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (arg1)->operator -((wxPoint const &)*arg2);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 wxPoint *arg2 = 0 ;
5924 wxPoint *result = 0 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 wxPoint temp2 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "self",(char *) "pt", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5936 if (!SWIG_IsOK(res1)) {
5937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5938 }
5939 arg1 = reinterpret_cast< wxPoint * >(argp1);
5940 {
5941 arg2 = &temp2;
5942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5943 }
5944 {
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 {
5947 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5948 result = (wxPoint *) &_result_ref;
5949 }
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 wxPoint *arg2 = 0 ;
5964 wxPoint *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 wxPoint temp2 ;
5968 PyObject * obj0 = 0 ;
5969 PyObject * obj1 = 0 ;
5970 char * kwnames[] = {
5971 (char *) "self",(char *) "pt", NULL
5972 };
5973
5974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 {
5987 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5988 result = (wxPoint *) &_result_ref;
5989 }
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 wxPoint *arg1 = (wxPoint *) 0 ;
6003 long arg2 ;
6004 long arg3 ;
6005 void *argp1 = 0 ;
6006 int res1 = 0 ;
6007 long val2 ;
6008 int ecode2 = 0 ;
6009 long val3 ;
6010 int ecode3 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 PyObject * obj2 = 0 ;
6014 char * kwnames[] = {
6015 (char *) "self",(char *) "x",(char *) "y", NULL
6016 };
6017
6018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6020 if (!SWIG_IsOK(res1)) {
6021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6022 }
6023 arg1 = reinterpret_cast< wxPoint * >(argp1);
6024 ecode2 = SWIG_AsVal_long(obj1, &val2);
6025 if (!SWIG_IsOK(ecode2)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6027 }
6028 arg2 = static_cast< long >(val2);
6029 ecode3 = SWIG_AsVal_long(obj2, &val3);
6030 if (!SWIG_IsOK(ecode3)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6032 }
6033 arg3 = static_cast< long >(val3);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 wxPoint_Set(arg1,arg2,arg3);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048 PyObject *resultobj = 0;
6049 wxPoint *arg1 = (wxPoint *) 0 ;
6050 PyObject *result = 0 ;
6051 void *argp1 = 0 ;
6052 int res1 = 0 ;
6053 PyObject *swig_obj[1] ;
6054
6055 if (!args) SWIG_fail;
6056 swig_obj[0] = args;
6057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (PyObject *)wxPoint_Get(arg1);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = result;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6076 PyObject *obj;
6077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6079 return SWIG_Py_Void();
6080 }
6081
6082 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083 return SWIG_Python_InitShadowInstance(args);
6084 }
6085
6086 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 int arg1 = (int) 0 ;
6089 int arg2 = (int) 0 ;
6090 int arg3 = (int) 0 ;
6091 int arg4 = (int) 0 ;
6092 wxRect *result = 0 ;
6093 int val1 ;
6094 int ecode1 = 0 ;
6095 int val2 ;
6096 int ecode2 = 0 ;
6097 int val3 ;
6098 int ecode3 = 0 ;
6099 int val4 ;
6100 int ecode4 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 PyObject * obj2 = 0 ;
6104 PyObject * obj3 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6110 if (obj0) {
6111 ecode1 = SWIG_AsVal_int(obj0, &val1);
6112 if (!SWIG_IsOK(ecode1)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6114 }
6115 arg1 = static_cast< int >(val1);
6116 }
6117 if (obj1) {
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 }
6124 if (obj2) {
6125 ecode3 = SWIG_AsVal_int(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6128 }
6129 arg3 = static_cast< int >(val3);
6130 }
6131 if (obj3) {
6132 ecode4 = SWIG_AsVal_int(obj3, &val4);
6133 if (!SWIG_IsOK(ecode4)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6135 }
6136 arg4 = static_cast< int >(val4);
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxPoint *arg1 = 0 ;
6154 wxPoint *arg2 = 0 ;
6155 wxRect *result = 0 ;
6156 wxPoint temp1 ;
6157 wxPoint temp2 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "topLeft",(char *) "bottomRight", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxPoint *arg1 = 0 ;
6189 wxSize *arg2 = 0 ;
6190 wxRect *result = 0 ;
6191 wxPoint temp1 ;
6192 wxSize temp2 ;
6193 PyObject * obj0 = 0 ;
6194 PyObject * obj1 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "pos",(char *) "size", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6200 {
6201 arg1 = &temp1;
6202 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6203 }
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxSize *arg1 = 0 ;
6224 wxRect *result = 0 ;
6225 wxSize temp1 ;
6226 PyObject * obj0 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "size", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6232 {
6233 arg1 = &temp1;
6234 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6235 }
6236 {
6237 PyThreadState* __tstate = wxPyBeginAllowThreads();
6238 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6250 PyObject *resultobj = 0;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 delete arg1;
6266
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 PyObject *swig_obj[1] ;
6284
6285 if (!args) SWIG_fail;
6286 swig_obj[0] = args;
6287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6288 if (!SWIG_IsOK(res1)) {
6289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6290 }
6291 arg1 = reinterpret_cast< wxRect * >(argp1);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (int)((wxRect const *)arg1)->GetX();
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_From_int(static_cast< int >(result));
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int arg2 ;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 int val2 ;
6312 int ecode2 = 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 char * kwnames[] = {
6316 (char *) "self",(char *) "x", NULL
6317 };
6318
6319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6321 if (!SWIG_IsOK(res1)) {
6322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6323 }
6324 arg1 = reinterpret_cast< wxRect * >(argp1);
6325 ecode2 = SWIG_AsVal_int(obj1, &val2);
6326 if (!SWIG_IsOK(ecode2)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6328 }
6329 arg2 = static_cast< int >(val2);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetX(arg2);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_Py_Void();
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (int)(arg1)->GetY();
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_From_int(static_cast< int >(result));
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int arg2 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "y", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6389 }
6390 arg1 = reinterpret_cast< wxRect * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetY(arg2);
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 PyObject *swig_obj[1] ;
6416
6417 if (!args) SWIG_fail;
6418 swig_obj[0] = args;
6419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6420 if (!SWIG_IsOK(res1)) {
6421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6422 }
6423 arg1 = reinterpret_cast< wxRect * >(argp1);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)((wxRect const *)arg1)->GetWidth();
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int arg2 ;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 int val2 ;
6444 int ecode2 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 char * kwnames[] = {
6448 (char *) "self",(char *) "w", NULL
6449 };
6450
6451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 ecode2 = SWIG_AsVal_int(obj1, &val2);
6458 if (!SWIG_IsOK(ecode2)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6460 }
6461 arg2 = static_cast< int >(val2);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->SetWidth(arg2);
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_Py_Void();
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int result;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 PyObject *swig_obj[1] ;
6482
6483 if (!args) SWIG_fail;
6484 swig_obj[0] = args;
6485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6486 if (!SWIG_IsOK(res1)) {
6487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6488 }
6489 arg1 = reinterpret_cast< wxRect * >(argp1);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (int)((wxRect const *)arg1)->GetHeight();
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_From_int(static_cast< int >(result));
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 int arg2 ;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 int val2 ;
6510 int ecode2 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 char * kwnames[] = {
6514 (char *) "self",(char *) "h", NULL
6515 };
6516
6517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 ecode2 = SWIG_AsVal_int(obj1, &val2);
6524 if (!SWIG_IsOK(ecode2)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6526 }
6527 arg2 = static_cast< int >(val2);
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 (arg1)->SetHeight(arg2);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_Py_Void();
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6542 PyObject *resultobj = 0;
6543 wxRect *arg1 = (wxRect *) 0 ;
6544 wxPoint result;
6545 void *argp1 = 0 ;
6546 int res1 = 0 ;
6547 PyObject *swig_obj[1] ;
6548
6549 if (!args) SWIG_fail;
6550 swig_obj[0] = args;
6551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6554 }
6555 arg1 = reinterpret_cast< wxRect * >(argp1);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = ((wxRect const *)arg1)->GetPosition();
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 wxPoint *arg2 = 0 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 wxPoint temp2 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "p", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 arg2 = &temp2;
6590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6591 }
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 (arg1)->SetPosition((wxPoint const &)*arg2);
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_Py_Void();
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6606 PyObject *resultobj = 0;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxSize result;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject *swig_obj[1] ;
6612
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = ((wxRect const *)arg1)->GetSize();
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxSize *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 wxSize temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "s", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetSize((wxSize const &)*arg2);
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 resultobj = SWIG_Py_Void();
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxRect *arg1 = (wxRect *) 0 ;
6672 bool result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)((wxRect const *)arg1)->IsEmpty();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxPoint result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxRect * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = ((wxRect const *)arg1)->GetTopLeft();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj = 0;
6729 wxRect *arg1 = (wxRect *) 0 ;
6730 wxPoint *arg2 = 0 ;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 wxPoint temp2 ;
6734 PyObject * obj0 = 0 ;
6735 PyObject * obj1 = 0 ;
6736 char * kwnames[] = {
6737 (char *) "self",(char *) "p", NULL
6738 };
6739
6740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6744 }
6745 arg1 = reinterpret_cast< wxRect * >(argp1);
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 wxPoint 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_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = ((wxRect const *)arg1)->GetBottomRight();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj = 0;
6793 wxRect *arg1 = (wxRect *) 0 ;
6794 wxPoint *arg2 = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 wxPoint temp2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char * kwnames[] = {
6801 (char *) "self",(char *) "p", NULL
6802 };
6803
6804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 resultobj = SWIG_Py_Void();
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxRect *arg1 = (wxRect *) 0 ;
6830 int result;
6831 void *argp1 = 0 ;
6832 int res1 = 0 ;
6833 PyObject *swig_obj[1] ;
6834
6835 if (!args) SWIG_fail;
6836 swig_obj[0] = args;
6837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (int)((wxRect const *)arg1)->GetLeft();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_From_int(static_cast< int >(result));
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 int result;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 PyObject *swig_obj[1] ;
6862
6863 if (!args) SWIG_fail;
6864 swig_obj[0] = args;
6865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6866 if (!SWIG_IsOK(res1)) {
6867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6868 }
6869 arg1 = reinterpret_cast< wxRect * >(argp1);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 result = (int)((wxRect const *)arg1)->GetTop();
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_From_int(static_cast< int >(result));
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int result;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 PyObject *swig_obj[1] ;
6890
6891 if (!args) SWIG_fail;
6892 swig_obj[0] = args;
6893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6894 if (!SWIG_IsOK(res1)) {
6895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6896 }
6897 arg1 = reinterpret_cast< wxRect * >(argp1);
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (int)((wxRect const *)arg1)->GetBottom();
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_From_int(static_cast< int >(result));
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxRect *arg1 = (wxRect *) 0 ;
6914 int result;
6915 void *argp1 = 0 ;
6916 int res1 = 0 ;
6917 PyObject *swig_obj[1] ;
6918
6919 if (!args) SWIG_fail;
6920 swig_obj[0] = args;
6921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (int)((wxRect const *)arg1)->GetRight();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_From_int(static_cast< int >(result));
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "left", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetLeft(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "right", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetRight(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "top", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 ecode2 = SWIG_AsVal_int(obj1, &val2);
7036 if (!SWIG_IsOK(ecode2)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7038 }
7039 arg2 = static_cast< int >(val2);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 (arg1)->SetTop(arg2);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj = 0;
7055 wxRect *arg1 = (wxRect *) 0 ;
7056 int arg2 ;
7057 void *argp1 = 0 ;
7058 int res1 = 0 ;
7059 int val2 ;
7060 int ecode2 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "self",(char *) "bottom", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7069 if (!SWIG_IsOK(res1)) {
7070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7071 }
7072 arg1 = reinterpret_cast< wxRect * >(argp1);
7073 ecode2 = SWIG_AsVal_int(obj1, &val2);
7074 if (!SWIG_IsOK(ecode2)) {
7075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7076 }
7077 arg2 = static_cast< int >(val2);
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->SetBottom(arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 int arg2 ;
7095 int arg3 ;
7096 wxRect *result = 0 ;
7097 void *argp1 = 0 ;
7098 int res1 = 0 ;
7099 int val2 ;
7100 int ecode2 = 0 ;
7101 int val3 ;
7102 int ecode3 = 0 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 PyObject * obj2 = 0 ;
7106 char * kwnames[] = {
7107 (char *) "self",(char *) "dx",(char *) "dy", NULL
7108 };
7109
7110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 ecode2 = SWIG_AsVal_int(obj1, &val2);
7117 if (!SWIG_IsOK(ecode2)) {
7118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7119 }
7120 arg2 = static_cast< int >(val2);
7121 ecode3 = SWIG_AsVal_int(obj2, &val3);
7122 if (!SWIG_IsOK(ecode3)) {
7123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7124 }
7125 arg3 = static_cast< int >(val3);
7126 {
7127 PyThreadState* __tstate = wxPyBeginAllowThreads();
7128 {
7129 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7130 result = (wxRect *) &_result_ref;
7131 }
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj = 0;
7144 wxRect *arg1 = (wxRect *) 0 ;
7145 int arg2 ;
7146 int arg3 ;
7147 wxRect *result = 0 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 int val3 ;
7153 int ecode3 = 0 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 PyObject * obj2 = 0 ;
7157 char * kwnames[] = {
7158 (char *) "self",(char *) "dx",(char *) "dy", NULL
7159 };
7160
7161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) 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_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7165 }
7166 arg1 = reinterpret_cast< wxRect * >(argp1);
7167 ecode2 = SWIG_AsVal_int(obj1, &val2);
7168 if (!SWIG_IsOK(ecode2)) {
7169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7170 }
7171 arg2 = static_cast< int >(val2);
7172 ecode3 = SWIG_AsVal_int(obj2, &val3);
7173 if (!SWIG_IsOK(ecode3)) {
7174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7175 }
7176 arg3 = static_cast< int >(val3);
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 {
7180 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7181 result = (wxRect *) &_result_ref;
7182 }
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj = 0;
7195 wxRect *arg1 = (wxRect *) 0 ;
7196 int arg2 ;
7197 int arg3 ;
7198 void *argp1 = 0 ;
7199 int res1 = 0 ;
7200 int val2 ;
7201 int ecode2 = 0 ;
7202 int val3 ;
7203 int ecode3 = 0 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 PyObject * obj2 = 0 ;
7207 char * kwnames[] = {
7208 (char *) "self",(char *) "dx",(char *) "dy", NULL
7209 };
7210
7211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7213 if (!SWIG_IsOK(res1)) {
7214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7215 }
7216 arg1 = reinterpret_cast< wxRect * >(argp1);
7217 ecode2 = SWIG_AsVal_int(obj1, &val2);
7218 if (!SWIG_IsOK(ecode2)) {
7219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7220 }
7221 arg2 = static_cast< int >(val2);
7222 ecode3 = SWIG_AsVal_int(obj2, &val3);
7223 if (!SWIG_IsOK(ecode3)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7225 }
7226 arg3 = static_cast< int >(val3);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->Offset(arg2,arg3);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 wxPoint *arg2 = 0 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 wxPoint temp2 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "pt", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 {
7260 arg2 = &temp2;
7261 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7262 }
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->Offset((wxPoint const &)*arg2);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxRect *arg1 = (wxRect *) 0 ;
7279 wxRect *arg2 = 0 ;
7280 wxRect result;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 wxRect temp2 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "rect", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 {
7297 arg2 = &temp2;
7298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (arg1)->Intersect((wxRect const &)*arg2);
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxRect *arg1 = (wxRect *) 0 ;
7316 wxRect *arg2 = 0 ;
7317 wxRect result;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 wxRect temp2 ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char * kwnames[] = {
7324 (char *) "self",(char *) "rect", NULL
7325 };
7326
7327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7331 }
7332 arg1 = reinterpret_cast< wxRect * >(argp1);
7333 {
7334 arg2 = &temp2;
7335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7336 }
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (arg1)->Union((wxRect const &)*arg2);
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 wxRect *arg2 = 0 ;
7354 wxRect result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 wxRect temp2 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "rect", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 {
7371 arg2 = &temp2;
7372 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxRect *arg2 = 0 ;
7391 wxRect *result = 0 ;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxRect temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "rect", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 {
7414 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7415 result = (wxRect *) &_result_ref;
7416 }
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxRect *arg1 = (wxRect *) 0 ;
7430 PyObject *arg2 = (PyObject *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "other", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 arg2 = obj1;
7447 {
7448 result = (bool)wxRect___eq__(arg1,arg2);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = 0;
7462 wxRect *arg1 = (wxRect *) 0 ;
7463 PyObject *arg2 = (PyObject *) 0 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char * kwnames[] = {
7470 (char *) "self",(char *) "other", NULL
7471 };
7472
7473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7477 }
7478 arg1 = reinterpret_cast< wxRect * >(argp1);
7479 arg2 = obj1;
7480 {
7481 result = (bool)wxRect___ne__(arg1,arg2);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 int arg2 ;
7497 int arg3 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 int val2 ;
7502 int ecode2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "x",(char *) "y", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7516 }
7517 arg1 = reinterpret_cast< wxRect * >(argp1);
7518 ecode2 = SWIG_AsVal_int(obj1, &val2);
7519 if (!SWIG_IsOK(ecode2)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7521 }
7522 arg2 = static_cast< int >(val2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxPoint *arg2 = 0 ;
7547 bool result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxPoint temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "pt", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 {
7574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7575 }
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxRect *arg1 = (wxRect *) 0 ;
7585 wxRect *arg2 = 0 ;
7586 bool result;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 wxRect temp2 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "rect", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7600 }
7601 arg1 = reinterpret_cast< wxRect * >(argp1);
7602 {
7603 arg2 = &temp2;
7604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7609 wxPyEndAllowThreads(__tstate);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 wxRect *arg2 = 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 wxRect temp2 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "rect", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7639 }
7640 arg1 = reinterpret_cast< wxRect * >(argp1);
7641 {
7642 arg2 = &temp2;
7643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7644 }
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxRect *arg1 = (wxRect *) 0 ;
7663 wxRect *arg2 = 0 ;
7664 int arg3 = (int) wxBOTH ;
7665 wxRect result;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 wxRect temp2 ;
7669 int val3 ;
7670 int ecode3 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 PyObject * obj2 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "r",(char *) "dir", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7682 }
7683 arg1 = reinterpret_cast< wxRect * >(argp1);
7684 {
7685 arg2 = &temp2;
7686 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7687 }
7688 if (obj2) {
7689 ecode3 = SWIG_AsVal_int(obj2, &val3);
7690 if (!SWIG_IsOK(ecode3)) {
7691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7692 }
7693 arg3 = static_cast< int >(val3);
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject *swig_obj[2] ;
7717
7718 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->x = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 int result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 PyObject *swig_obj[1] ;
7745
7746 if (!args) SWIG_fail;
7747 swig_obj[0] = args;
7748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->x);
7754 resultobj = SWIG_From_int(static_cast< int >(result));
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 int arg2 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 int val2 ;
7768 int ecode2 = 0 ;
7769 PyObject *swig_obj[2] ;
7770
7771 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->y = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 int result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 PyObject *swig_obj[1] ;
7798
7799 if (!args) SWIG_fail;
7800 swig_obj[0] = args;
7801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->y);
7807 resultobj = SWIG_From_int(static_cast< int >(result));
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 PyObject *swig_obj[2] ;
7823
7824 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7826 if (!SWIG_IsOK(res1)) {
7827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7828 }
7829 arg1 = reinterpret_cast< wxRect * >(argp1);
7830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7831 if (!SWIG_IsOK(ecode2)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7833 }
7834 arg2 = static_cast< int >(val2);
7835 if (arg1) (arg1)->width = arg2;
7836
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7845 PyObject *resultobj = 0;
7846 wxRect *arg1 = (wxRect *) 0 ;
7847 int result;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 PyObject *swig_obj[1] ;
7851
7852 if (!args) SWIG_fail;
7853 swig_obj[0] = args;
7854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7855 if (!SWIG_IsOK(res1)) {
7856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7857 }
7858 arg1 = reinterpret_cast< wxRect * >(argp1);
7859 result = (int) ((arg1)->width);
7860 resultobj = SWIG_From_int(static_cast< int >(result));
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 int arg2 ;
7871 void *argp1 = 0 ;
7872 int res1 = 0 ;
7873 int val2 ;
7874 int ecode2 = 0 ;
7875 PyObject *swig_obj[2] ;
7876
7877 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7884 if (!SWIG_IsOK(ecode2)) {
7885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7886 }
7887 arg2 = static_cast< int >(val2);
7888 if (arg1) (arg1)->height = arg2;
7889
7890 resultobj = SWIG_Py_Void();
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7898 PyObject *resultobj = 0;
7899 wxRect *arg1 = (wxRect *) 0 ;
7900 int result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 PyObject *swig_obj[1] ;
7904
7905 if (!args) SWIG_fail;
7906 swig_obj[0] = args;
7907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 result = (int) ((arg1)->height);
7913 resultobj = SWIG_From_int(static_cast< int >(result));
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 int arg2 = (int) 0 ;
7924 int arg3 = (int) 0 ;
7925 int arg4 = (int) 0 ;
7926 int arg5 = (int) 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 int val2 ;
7930 int ecode2 = 0 ;
7931 int val3 ;
7932 int ecode3 = 0 ;
7933 int val4 ;
7934 int ecode4 = 0 ;
7935 int val5 ;
7936 int ecode5 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 PyObject * obj2 = 0 ;
7940 PyObject * obj3 = 0 ;
7941 PyObject * obj4 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7950 }
7951 arg1 = reinterpret_cast< wxRect * >(argp1);
7952 if (obj1) {
7953 ecode2 = SWIG_AsVal_int(obj1, &val2);
7954 if (!SWIG_IsOK(ecode2)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7956 }
7957 arg2 = static_cast< int >(val2);
7958 }
7959 if (obj2) {
7960 ecode3 = SWIG_AsVal_int(obj2, &val3);
7961 if (!SWIG_IsOK(ecode3)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7963 }
7964 arg3 = static_cast< int >(val3);
7965 }
7966 if (obj3) {
7967 ecode4 = SWIG_AsVal_int(obj3, &val4);
7968 if (!SWIG_IsOK(ecode4)) {
7969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7970 }
7971 arg4 = static_cast< int >(val4);
7972 }
7973 if (obj4) {
7974 ecode5 = SWIG_AsVal_int(obj4, &val5);
7975 if (!SWIG_IsOK(ecode5)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7977 }
7978 arg5 = static_cast< int >(val5);
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_Py_Void();
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995 wxRect *arg1 = (wxRect *) 0 ;
7996 PyObject *result = 0 ;
7997 void *argp1 = 0 ;
7998 int res1 = 0 ;
7999 PyObject *swig_obj[1] ;
8000
8001 if (!args) SWIG_fail;
8002 swig_obj[0] = args;
8003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8004 if (!SWIG_IsOK(res1)) {
8005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8006 }
8007 arg1 = reinterpret_cast< wxRect * >(argp1);
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 result = (PyObject *)wxRect_Get(arg1);
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = result;
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *obj;
8023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8024 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8025 return SWIG_Py_Void();
8026 }
8027
8028 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 return SWIG_Python_InitShadowInstance(args);
8030 }
8031
8032 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj = 0;
8034 wxRect *arg1 = (wxRect *) 0 ;
8035 wxRect *arg2 = (wxRect *) 0 ;
8036 PyObject *result = 0 ;
8037 void *argp1 = 0 ;
8038 int res1 = 0 ;
8039 void *argp2 = 0 ;
8040 int res2 = 0 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "r1",(char *) "r2", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8049 if (!SWIG_IsOK(res1)) {
8050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8051 }
8052 arg1 = reinterpret_cast< wxRect * >(argp1);
8053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8054 if (!SWIG_IsOK(res2)) {
8055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8056 }
8057 arg2 = reinterpret_cast< wxRect * >(argp2);
8058 {
8059 if (!wxPyCheckForApp()) SWIG_fail;
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (PyObject *)wxIntersectRect(arg1,arg2);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = result;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 double arg1 = (double) 0.0 ;
8075 double arg2 = (double) 0.0 ;
8076 wxPoint2D *result = 0 ;
8077 double val1 ;
8078 int ecode1 = 0 ;
8079 double val2 ;
8080 int ecode2 = 0 ;
8081 PyObject * obj0 = 0 ;
8082 PyObject * obj1 = 0 ;
8083 char * kwnames[] = {
8084 (char *) "x",(char *) "y", NULL
8085 };
8086
8087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8088 if (obj0) {
8089 ecode1 = SWIG_AsVal_double(obj0, &val1);
8090 if (!SWIG_IsOK(ecode1)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8092 }
8093 arg1 = static_cast< double >(val1);
8094 }
8095 if (obj1) {
8096 ecode2 = SWIG_AsVal_double(obj1, &val2);
8097 if (!SWIG_IsOK(ecode2)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8099 }
8100 arg2 = static_cast< double >(val2);
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj = 0;
8117 wxPoint2D *arg1 = 0 ;
8118 wxPoint2D *result = 0 ;
8119 wxPoint2D temp1 ;
8120 PyObject * obj0 = 0 ;
8121 char * kwnames[] = {
8122 (char *) "pt", NULL
8123 };
8124
8125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8126 {
8127 arg1 = &temp1;
8128 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8129 }
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj = 0;
8145 wxPoint *arg1 = 0 ;
8146 wxPoint2D *result = 0 ;
8147 wxPoint temp1 ;
8148 PyObject * obj0 = 0 ;
8149 char * kwnames[] = {
8150 (char *) "pt", NULL
8151 };
8152
8153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8154 {
8155 arg1 = &temp1;
8156 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8157 }
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *resultobj = 0;
8173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8174 int *arg2 = (int *) 0 ;
8175 int *arg3 = (int *) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int temp2 ;
8179 int res2 = SWIG_TMPOBJ ;
8180 int temp3 ;
8181 int res3 = SWIG_TMPOBJ ;
8182 PyObject *swig_obj[1] ;
8183
8184 arg2 = &temp2;
8185 arg3 = &temp3;
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_Py_Void();
8200 if (SWIG_IsTmpObj(res2)) {
8201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8202 } else {
8203 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8205 }
8206 if (SWIG_IsTmpObj(res3)) {
8207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8208 } else {
8209 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8211 }
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8221 int *arg2 = (int *) 0 ;
8222 int *arg3 = (int *) 0 ;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 int temp2 ;
8226 int res2 = SWIG_TMPOBJ ;
8227 int temp3 ;
8228 int res3 = SWIG_TMPOBJ ;
8229 PyObject *swig_obj[1] ;
8230
8231 arg2 = &temp2;
8232 arg3 = &temp3;
8233 if (!args) SWIG_fail;
8234 swig_obj[0] = args;
8235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8238 }
8239 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 if (SWIG_IsTmpObj(res2)) {
8248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8249 } else {
8250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8252 }
8253 if (SWIG_IsTmpObj(res3)) {
8254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8255 } else {
8256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *resultobj = 0;
8267 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8268 double result;
8269 void *argp1 = 0 ;
8270 int res1 = 0 ;
8271 PyObject *swig_obj[1] ;
8272
8273 if (!args) SWIG_fail;
8274 swig_obj[0] = args;
8275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8276 if (!SWIG_IsOK(res1)) {
8277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8278 }
8279 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = SWIG_From_double(static_cast< double >(result));
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8294 PyObject *resultobj = 0;
8295 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8296 double result;
8297 void *argp1 = 0 ;
8298 int res1 = 0 ;
8299 PyObject *swig_obj[1] ;
8300
8301 if (!args) SWIG_fail;
8302 swig_obj[0] = args;
8303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 PyThreadState* __tstate = wxPyBeginAllowThreads();
8310 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 resultobj = SWIG_From_double(static_cast< double >(result));
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj = 0;
8323 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8324 double arg2 ;
8325 void *argp1 = 0 ;
8326 int res1 = 0 ;
8327 double val2 ;
8328 int ecode2 = 0 ;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 char * kwnames[] = {
8332 (char *) "self",(char *) "length", NULL
8333 };
8334
8335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8339 }
8340 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 (arg1)->SetVectorLength(arg2);
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 return resultobj;
8354 fail:
8355 return NULL;
8356 }
8357
8358
8359 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj = 0;
8361 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8362 double arg2 ;
8363 void *argp1 = 0 ;
8364 int res1 = 0 ;
8365 double val2 ;
8366 int ecode2 = 0 ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "degrees", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8377 }
8378 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8379 ecode2 = SWIG_AsVal_double(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8382 }
8383 arg2 = static_cast< double >(val2);
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 (arg1)->SetVectorAngle(arg2);
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 wxPoint2D *arg2 = 0 ;
8401 double result;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 wxPoint2D temp2 ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 char * kwnames[] = {
8408 (char *) "self",(char *) "pt", NULL
8409 };
8410
8411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8413 if (!SWIG_IsOK(res1)) {
8414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8415 }
8416 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8417 {
8418 arg2 = &temp2;
8419 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_From_double(static_cast< double >(result));
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = 0;
8436 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8437 wxPoint2D *arg2 = 0 ;
8438 double result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 wxPoint2D temp2 ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char * kwnames[] = {
8445 (char *) "self",(char *) "pt", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 arg2 = &temp2;
8456 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 resultobj = SWIG_From_double(static_cast< double >(result));
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 wxPoint2D *arg2 = 0 ;
8475 double result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 wxPoint2D temp2 ;
8479 PyObject * obj0 = 0 ;
8480 PyObject * obj1 = 0 ;
8481 char * kwnames[] = {
8482 (char *) "self",(char *) "vec", NULL
8483 };
8484
8485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8487 if (!SWIG_IsOK(res1)) {
8488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8489 }
8490 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8491 {
8492 arg2 = &temp2;
8493 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8494 }
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_From_double(static_cast< double >(result));
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 double result;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "vec", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_From_double(static_cast< double >(result));
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 wxPoint2D result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (arg1)->operator -();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 wxPoint2D *arg2 = 0 ;
8577 wxPoint2D *result = 0 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint2D temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 {
8600 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8601 result = (wxPoint2D *) &_result_ref;
8602 }
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 wxPoint2D *arg2 = 0 ;
8617 wxPoint2D *result = 0 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 wxPoint2D temp2 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "pt", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 {
8634 arg2 = &temp2;
8635 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8636 }
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 {
8640 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8641 result = (wxPoint2D *) &_result_ref;
8642 }
8643 wxPyEndAllowThreads(__tstate);
8644 if (PyErr_Occurred()) SWIG_fail;
8645 }
8646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = 0;
8655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8656 wxPoint2D *arg2 = 0 ;
8657 wxPoint2D *result = 0 ;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 wxPoint2D temp2 ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char * kwnames[] = {
8664 (char *) "self",(char *) "pt", NULL
8665 };
8666
8667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8671 }
8672 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8673 {
8674 arg2 = &temp2;
8675 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 {
8680 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8681 result = (wxPoint2D *) &_result_ref;
8682 }
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D *arg2 = 0 ;
8697 wxPoint2D *result = 0 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 wxPoint2D temp2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "pt", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 {
8714 arg2 = &temp2;
8715 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 {
8720 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8721 result = (wxPoint2D *) &_result_ref;
8722 }
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 PyObject *arg2 = (PyObject *) 0 ;
8737 bool result;
8738 void *argp1 = 0 ;
8739 int res1 = 0 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "other", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 arg2 = obj1;
8753 {
8754 result = (bool)wxPoint2D___eq__(arg1,arg2);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 {
8758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8759 }
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 PyObject *arg2 = (PyObject *) 0 ;
8770 bool result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 char * kwnames[] = {
8776 (char *) "self",(char *) "other", NULL
8777 };
8778
8779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8781 if (!SWIG_IsOK(res1)) {
8782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8783 }
8784 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8785 arg2 = obj1;
8786 {
8787 result = (bool)wxPoint2D___ne__(arg1,arg2);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 {
8791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8792 }
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 double val2 ;
8806 int ecode2 = 0 ;
8807 PyObject *swig_obj[2] ;
8808
8809 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 if (arg1) (arg1)->m_x = arg2;
8821
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8830 PyObject *resultobj = 0;
8831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8832 double result;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 PyObject *swig_obj[1] ;
8836
8837 if (!args) SWIG_fail;
8838 swig_obj[0] = args;
8839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8840 if (!SWIG_IsOK(res1)) {
8841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8842 }
8843 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8844 result = (double) ((arg1)->m_x);
8845 resultobj = SWIG_From_double(static_cast< double >(result));
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 PyObject *resultobj = 0;
8854 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8855 double arg2 ;
8856 void *argp1 = 0 ;
8857 int res1 = 0 ;
8858 double val2 ;
8859 int ecode2 = 0 ;
8860 PyObject *swig_obj[2] ;
8861
8862 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8864 if (!SWIG_IsOK(res1)) {
8865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8866 }
8867 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8869 if (!SWIG_IsOK(ecode2)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8871 }
8872 arg2 = static_cast< double >(val2);
8873 if (arg1) (arg1)->m_y = arg2;
8874
8875 resultobj = SWIG_Py_Void();
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 PyObject *resultobj = 0;
8884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8885 double result;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject *swig_obj[1] ;
8889
8890 if (!args) SWIG_fail;
8891 swig_obj[0] = args;
8892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8893 if (!SWIG_IsOK(res1)) {
8894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8895 }
8896 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8897 result = (double) ((arg1)->m_y);
8898 resultobj = SWIG_From_double(static_cast< double >(result));
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 double arg2 = (double) 0 ;
8909 double arg3 = (double) 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 double val2 ;
8913 int ecode2 = 0 ;
8914 double val3 ;
8915 int ecode3 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "self",(char *) "x",(char *) "y", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8927 }
8928 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8929 if (obj1) {
8930 ecode2 = SWIG_AsVal_double(obj1, &val2);
8931 if (!SWIG_IsOK(ecode2)) {
8932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8933 }
8934 arg2 = static_cast< double >(val2);
8935 }
8936 if (obj2) {
8937 ecode3 = SWIG_AsVal_double(obj2, &val3);
8938 if (!SWIG_IsOK(ecode3)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8940 }
8941 arg3 = static_cast< double >(val3);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 wxPoint2D_Set(arg1,arg2,arg3);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8959 PyObject *result = 0 ;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 PyObject *swig_obj[1] ;
8963
8964 if (!args) SWIG_fail;
8965 swig_obj[0] = args;
8966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (PyObject *)wxPoint2D_Get(arg1);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = result;
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8985 PyObject *obj;
8986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8988 return SWIG_Py_Void();
8989 }
8990
8991 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 return SWIG_Python_InitShadowInstance(args);
8993 }
8994
8995 SWIGINTERN int DefaultPosition_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultPosition_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN int DefaultSize_set(PyObject *) {
9010 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9011 return 1;
9012 }
9013
9014
9015 SWIGINTERN PyObject *DefaultSize_get(void) {
9016 PyObject *pyobj = 0;
9017
9018 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9019 return pyobj;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9024 PyObject *resultobj = 0;
9025 PyObject *arg1 = (PyObject *) 0 ;
9026 wxPyInputStream *result = 0 ;
9027 PyObject * obj0 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "p", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9033 arg1 = obj0;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048 PyObject *resultobj = 0;
9049 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject *swig_obj[1] ;
9053
9054 if (!args) SWIG_fail;
9055 swig_obj[0] = args;
9056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 delete arg1;
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = SWIG_Py_Void();
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 PyObject *swig_obj[1] ;
9081
9082 if (!args) SWIG_fail;
9083 swig_obj[0] = args;
9084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9085 if (!SWIG_IsOK(res1)) {
9086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9087 }
9088 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 (arg1)->close();
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 (arg1)->flush();
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *resultobj = 0;
9131 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9132 bool result;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 PyObject *swig_obj[1] ;
9136
9137 if (!args) SWIG_fail;
9138 swig_obj[0] = args;
9139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9142 }
9143 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (bool)(arg1)->eof();
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 {
9151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 int arg2 = (int) -1 ;
9163 PyObject *result = 0 ;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 int val2 ;
9167 int ecode2 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char * kwnames[] = {
9171 (char *) "self",(char *) "size", NULL
9172 };
9173
9174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9180 if (obj1) {
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 result = (PyObject *)(arg1)->read(arg2);
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 resultobj = result;
9194 return resultobj;
9195 fail:
9196 return NULL;
9197 }
9198
9199
9200 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj = 0;
9202 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9203 int arg2 = (int) -1 ;
9204 PyObject *result = 0 ;
9205 void *argp1 = 0 ;
9206 int res1 = 0 ;
9207 int val2 ;
9208 int ecode2 = 0 ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 char * kwnames[] = {
9212 (char *) "self",(char *) "size", NULL
9213 };
9214
9215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 if (obj1) {
9222 ecode2 = SWIG_AsVal_int(obj1, &val2);
9223 if (!SWIG_IsOK(ecode2)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9225 }
9226 arg2 = static_cast< int >(val2);
9227 }
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 result = (PyObject *)(arg1)->readline(arg2);
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = result;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj = 0;
9243 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9244 int arg2 = (int) -1 ;
9245 PyObject *result = 0 ;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 int val2 ;
9249 int ecode2 = 0 ;
9250 PyObject * obj0 = 0 ;
9251 PyObject * obj1 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "sizehint", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9260 }
9261 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9262 if (obj1) {
9263 ecode2 = SWIG_AsVal_int(obj1, &val2);
9264 if (!SWIG_IsOK(ecode2)) {
9265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9266 }
9267 arg2 = static_cast< int >(val2);
9268 }
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (PyObject *)(arg1)->readlines(arg2);
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = result;
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 int arg2 ;
9286 int arg3 = (int) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 int val2 ;
9290 int ecode2 = 0 ;
9291 int val3 ;
9292 int ecode3 = 0 ;
9293 PyObject * obj0 = 0 ;
9294 PyObject * obj1 = 0 ;
9295 PyObject * obj2 = 0 ;
9296 char * kwnames[] = {
9297 (char *) "self",(char *) "offset",(char *) "whence", NULL
9298 };
9299
9300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9304 }
9305 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9306 ecode2 = SWIG_AsVal_int(obj1, &val2);
9307 if (!SWIG_IsOK(ecode2)) {
9308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9309 }
9310 arg2 = static_cast< int >(val2);
9311 if (obj2) {
9312 ecode3 = SWIG_AsVal_int(obj2, &val3);
9313 if (!SWIG_IsOK(ecode3)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9315 }
9316 arg3 = static_cast< int >(val3);
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->seek(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9334 int result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9344 }
9345 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (int)(arg1)->tell();
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_From_int(static_cast< int >(result));
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 char result;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 PyObject *swig_obj[1] ;
9366
9367 if (!args) SWIG_fail;
9368 swig_obj[0] = args;
9369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9370 if (!SWIG_IsOK(res1)) {
9371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9372 }
9373 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (char)(arg1)->Peek();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_From_char(static_cast< char >(result));
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 PyObject *swig_obj[1] ;
9394
9395 if (!args) SWIG_fail;
9396 swig_obj[0] = args;
9397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9398 if (!SWIG_IsOK(res1)) {
9399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9400 }
9401 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 result = (char)(arg1)->GetC();
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_From_char(static_cast< char >(result));
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 size_t result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (size_t)(arg1)->LastRead();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 PyObject *resultobj = 0;
9445 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9446 bool result;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 PyObject *swig_obj[1] ;
9450
9451 if (!args) SWIG_fail;
9452 swig_obj[0] = args;
9453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 {
9459 PyThreadState* __tstate = wxPyBeginAllowThreads();
9460 result = (bool)(arg1)->CanRead();
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 {
9465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9466 }
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 bool result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (bool)(arg1)->Eof();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 {
9495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9496 }
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = 0;
9505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9506 char arg2 ;
9507 bool result;
9508 void *argp1 = 0 ;
9509 int res1 = 0 ;
9510 char val2 ;
9511 int ecode2 = 0 ;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 char * kwnames[] = {
9515 (char *) "self",(char *) "c", NULL
9516 };
9517
9518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9520 if (!SWIG_IsOK(res1)) {
9521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9522 }
9523 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9524 ecode2 = SWIG_AsVal_char(obj1, &val2);
9525 if (!SWIG_IsOK(ecode2)) {
9526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9527 }
9528 arg2 = static_cast< char >(val2);
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (bool)(arg1)->Ungetch(arg2);
9532 wxPyEndAllowThreads(__tstate);
9533 if (PyErr_Occurred()) SWIG_fail;
9534 }
9535 {
9536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9537 }
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9547 long arg2 ;
9548 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9549 long result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 long val2 ;
9553 int ecode2 = 0 ;
9554 int val3 ;
9555 int ecode3 = 0 ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 PyObject * obj2 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "pos",(char *) "mode", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9567 }
9568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9569 ecode2 = SWIG_AsVal_long(obj1, &val2);
9570 if (!SWIG_IsOK(ecode2)) {
9571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9572 }
9573 arg2 = static_cast< long >(val2);
9574 if (obj2) {
9575 ecode3 = SWIG_AsVal_int(obj2, &val3);
9576 if (!SWIG_IsOK(ecode3)) {
9577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9578 }
9579 arg3 = static_cast< wxSeekMode >(val3);
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (long)(arg1)->SeekI(arg2,arg3);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_From_long(static_cast< long >(result));
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9595 PyObject *resultobj = 0;
9596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9597 long result;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 PyObject *swig_obj[1] ;
9601
9602 if (!args) SWIG_fail;
9603 swig_obj[0] = args;
9604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9607 }
9608 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (long)(arg1)->TellI();
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_From_long(static_cast< long >(result));
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9623 PyObject *obj;
9624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9626 return SWIG_Py_Void();
9627 }
9628
9629 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630 return SWIG_Python_InitShadowInstance(args);
9631 }
9632
9633 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char * kwnames[] = {
9642 (char *) "self",(char *) "obj", NULL
9643 };
9644
9645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9647 if (!SWIG_IsOK(res1)) {
9648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9649 }
9650 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9651 arg2 = obj1;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 wxOutputStream_write(arg1,arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9668 size_t result;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9678 }
9679 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9694 PyObject *obj;
9695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9696 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9697 return SWIG_Py_Void();
9698 }
9699
9700 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj = 0;
9702 wxInputStream *arg1 = (wxInputStream *) 0 ;
9703 wxString *arg2 = 0 ;
9704 wxString *arg3 = 0 ;
9705 wxString *arg4 = 0 ;
9706 wxDateTime arg5 ;
9707 wxFSFile *result = 0 ;
9708 wxPyInputStream *temp1 ;
9709 bool temp2 = false ;
9710 bool temp3 = false ;
9711 bool temp4 = false ;
9712 void *argp5 ;
9713 int res5 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 PyObject * obj2 = 0 ;
9717 PyObject * obj3 = 0 ;
9718 PyObject * obj4 = 0 ;
9719 char * kwnames[] = {
9720 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9721 };
9722
9723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9724 {
9725 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9726 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9727 } else {
9728 PyErr_Clear(); // clear the failure of the wxPyConvert above
9729 arg1 = wxPyCBInputStream_create(obj0, true);
9730 if (arg1 == NULL) {
9731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9732 SWIG_fail;
9733 }
9734 }
9735 }
9736 {
9737 arg2 = wxString_in_helper(obj1);
9738 if (arg2 == NULL) SWIG_fail;
9739 temp2 = true;
9740 }
9741 {
9742 arg3 = wxString_in_helper(obj2);
9743 if (arg3 == NULL) SWIG_fail;
9744 temp3 = true;
9745 }
9746 {
9747 arg4 = wxString_in_helper(obj3);
9748 if (arg4 == NULL) SWIG_fail;
9749 temp4 = true;
9750 }
9751 {
9752 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9753 if (!SWIG_IsOK(res5)) {
9754 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9755 }
9756 if (!argp5) {
9757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9758 } else {
9759 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9760 arg5 = *temp;
9761 if (SWIG_IsNewObj(res5)) delete temp;
9762 }
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return resultobj;
9784 fail:
9785 {
9786 if (temp2)
9787 delete arg2;
9788 }
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 {
9794 if (temp4)
9795 delete arg4;
9796 }
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802 PyObject *resultobj = 0;
9803 wxFSFile *arg1 = (wxFSFile *) 0 ;
9804 void *argp1 = 0 ;
9805 int res1 = 0 ;
9806 PyObject *swig_obj[1] ;
9807
9808 if (!args) SWIG_fail;
9809 swig_obj[0] = args;
9810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9813 }
9814 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9815 {
9816 PyThreadState* __tstate = wxPyBeginAllowThreads();
9817 delete arg1;
9818
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 resultobj = SWIG_Py_Void();
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxInputStream *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (wxInputStream *)(arg1)->GetStream();
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 wxPyInputStream * _ptr = NULL;
9852
9853 if (result) {
9854 _ptr = new wxPyInputStream(result);
9855 }
9856 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxFSFile *arg1 = (wxFSFile *) 0 ;
9867 wxString *result = 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 {
9882 wxString const &_result_ref = (arg1)->GetMimeType();
9883 result = (wxString *) &_result_ref;
9884 }
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFSFile *arg1 = (wxFSFile *) 0 ;
9904 wxString *result = 0 ;
9905 void *argp1 = 0 ;
9906 int res1 = 0 ;
9907 PyObject *swig_obj[1] ;
9908
9909 if (!args) SWIG_fail;
9910 swig_obj[0] = args;
9911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9914 }
9915 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 {
9919 wxString const &_result_ref = (arg1)->GetLocation();
9920 result = (wxString *) &_result_ref;
9921 }
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 {
9926 #if wxUSE_UNICODE
9927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9928 #else
9929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9930 #endif
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9939 PyObject *resultobj = 0;
9940 wxFSFile *arg1 = (wxFSFile *) 0 ;
9941 wxString *result = 0 ;
9942 void *argp1 = 0 ;
9943 int res1 = 0 ;
9944 PyObject *swig_obj[1] ;
9945
9946 if (!args) SWIG_fail;
9947 swig_obj[0] = args;
9948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9949 if (!SWIG_IsOK(res1)) {
9950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9951 }
9952 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 {
9956 wxString const &_result_ref = (arg1)->GetAnchor();
9957 result = (wxString *) &_result_ref;
9958 }
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9976 PyObject *resultobj = 0;
9977 wxFSFile *arg1 = (wxFSFile *) 0 ;
9978 wxDateTime result;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 PyObject *swig_obj[1] ;
9982
9983 if (!args) SWIG_fail;
9984 swig_obj[0] = args;
9985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9988 }
9989 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (arg1)->GetModificationTime();
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *obj;
10005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10006 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10007 return SWIG_Py_Void();
10008 }
10009
10010 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10011 return SWIG_Python_InitShadowInstance(args);
10012 }
10013
10014 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015 PyObject *resultobj = 0;
10016 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10017 void *argp1 = 0 ;
10018 int res1 = 0 ;
10019 PyObject *swig_obj[1] ;
10020
10021 if (!args) SWIG_fail;
10022 swig_obj[0] = args;
10023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10026 }
10027 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 delete arg1;
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *obj;
10044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10045 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10046 return SWIG_Py_Void();
10047 }
10048
10049 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050 PyObject *resultobj = 0;
10051 wxPyFileSystemHandler *result = 0 ;
10052
10053 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10061 return resultobj;
10062 fail:
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj = 0;
10069 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10070 PyObject *arg2 = (PyObject *) 0 ;
10071 PyObject *arg3 = (PyObject *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 PyObject * obj0 = 0 ;
10075 PyObject * obj1 = 0 ;
10076 PyObject * obj2 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "self",(char *) "_class", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10085 }
10086 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10087 arg2 = obj1;
10088 arg3 = obj2;
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 (arg1)->_setCallbackInfo(arg2,arg3);
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10105 wxString *arg2 = 0 ;
10106 bool result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "location", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10120 }
10121 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10122 {
10123 arg2 = wxString_in_helper(obj1);
10124 if (arg2 == NULL) SWIG_fail;
10125 temp2 = true;
10126 }
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 {
10134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxFileSystem *arg2 = 0 ;
10154 wxString *arg3 = 0 ;
10155 wxFSFile *result = 0 ;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 void *argp2 = 0 ;
10159 int res2 = 0 ;
10160 bool temp3 = false ;
10161 PyObject * obj0 = 0 ;
10162 PyObject * obj1 = 0 ;
10163 PyObject * obj2 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "self",(char *) "fs",(char *) "location", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10175 if (!SWIG_IsOK(res2)) {
10176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10177 }
10178 if (!argp2) {
10179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10180 }
10181 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10182 {
10183 arg3 = wxString_in_helper(obj2);
10184 if (arg3 == NULL) SWIG_fail;
10185 temp3 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10195 }
10196 {
10197 if (temp3)
10198 delete arg3;
10199 }
10200 return resultobj;
10201 fail:
10202 {
10203 if (temp3)
10204 delete arg3;
10205 }
10206 return NULL;
10207 }
10208
10209
10210 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj = 0;
10212 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10213 wxString *arg2 = 0 ;
10214 int arg3 = (int) 0 ;
10215 wxString result;
10216 void *argp1 = 0 ;
10217 int res1 = 0 ;
10218 bool temp2 = false ;
10219 int val3 ;
10220 int ecode3 = 0 ;
10221 PyObject * obj0 = 0 ;
10222 PyObject * obj1 = 0 ;
10223 PyObject * obj2 = 0 ;
10224 char * kwnames[] = {
10225 (char *) "self",(char *) "spec",(char *) "flags", NULL
10226 };
10227
10228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10230 if (!SWIG_IsOK(res1)) {
10231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10232 }
10233 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10234 {
10235 arg2 = wxString_in_helper(obj1);
10236 if (arg2 == NULL) SWIG_fail;
10237 temp2 = true;
10238 }
10239 if (obj2) {
10240 ecode3 = SWIG_AsVal_int(obj2, &val3);
10241 if (!SWIG_IsOK(ecode3)) {
10242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10243 }
10244 arg3 = static_cast< int >(val3);
10245 }
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 {
10253 #if wxUSE_UNICODE
10254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10255 #else
10256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10257 #endif
10258 }
10259 {
10260 if (temp2)
10261 delete arg2;
10262 }
10263 return resultobj;
10264 fail:
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return NULL;
10270 }
10271
10272
10273 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10274 PyObject *resultobj = 0;
10275 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10276 wxString result;
10277 void *argp1 = 0 ;
10278 int res1 = 0 ;
10279 PyObject *swig_obj[1] ;
10280
10281 if (!args) SWIG_fail;
10282 swig_obj[0] = args;
10283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10284 if (!SWIG_IsOK(res1)) {
10285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10286 }
10287 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 result = (arg1)->FindNext();
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 #if wxUSE_UNICODE
10296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10297 #else
10298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10299 #endif
10300 }
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj = 0;
10309 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10310 wxString *arg2 = 0 ;
10311 wxString result;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 bool temp2 = false ;
10315 PyObject * obj0 = 0 ;
10316 PyObject * obj1 = 0 ;
10317 char * kwnames[] = {
10318 (char *) "self",(char *) "location", NULL
10319 };
10320
10321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10323 if (!SWIG_IsOK(res1)) {
10324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10325 }
10326 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10327 {
10328 arg2 = wxString_in_helper(obj1);
10329 if (arg2 == NULL) SWIG_fail;
10330 temp2 = true;
10331 }
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (arg1)->GetProtocol((wxString const &)*arg2);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 #if wxUSE_UNICODE
10340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10341 #else
10342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10343 #endif
10344 }
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp2)
10353 delete arg2;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = 0;
10361 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10362 wxString *arg2 = 0 ;
10363 wxString result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 bool temp2 = false ;
10367 PyObject * obj0 = 0 ;
10368 PyObject * obj1 = 0 ;
10369 char * kwnames[] = {
10370 (char *) "self",(char *) "location", NULL
10371 };
10372
10373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10375 if (!SWIG_IsOK(res1)) {
10376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10377 }
10378 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10379 {
10380 arg2 = wxString_in_helper(obj1);
10381 if (arg2 == NULL) SWIG_fail;
10382 temp2 = true;
10383 }
10384 {
10385 PyThreadState* __tstate = wxPyBeginAllowThreads();
10386 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10387 wxPyEndAllowThreads(__tstate);
10388 if (PyErr_Occurred()) SWIG_fail;
10389 }
10390 {
10391 #if wxUSE_UNICODE
10392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10393 #else
10394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10395 #endif
10396 }
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return resultobj;
10402 fail:
10403 {
10404 if (temp2)
10405 delete arg2;
10406 }
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = 0;
10413 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10414 wxString *arg2 = 0 ;
10415 wxString result;
10416 void *argp1 = 0 ;
10417 int res1 = 0 ;
10418 bool temp2 = false ;
10419 PyObject * obj0 = 0 ;
10420 PyObject * obj1 = 0 ;
10421 char * kwnames[] = {
10422 (char *) "self",(char *) "location", NULL
10423 };
10424
10425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10431 {
10432 arg2 = wxString_in_helper(obj1);
10433 if (arg2 == NULL) SWIG_fail;
10434 temp2 = true;
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (arg1)->GetAnchor((wxString const &)*arg2);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 #if wxUSE_UNICODE
10444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10445 #else
10446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10447 #endif
10448 }
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return resultobj;
10454 fail:
10455 {
10456 if (temp2)
10457 delete arg2;
10458 }
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10464 PyObject *resultobj = 0;
10465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10466 wxString *arg2 = 0 ;
10467 wxString result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 bool temp2 = false ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 char * kwnames[] = {
10474 (char *) "self",(char *) "location", NULL
10475 };
10476
10477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10481 }
10482 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10483 {
10484 arg2 = wxString_in_helper(obj1);
10485 if (arg2 == NULL) SWIG_fail;
10486 temp2 = true;
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp2)
10509 delete arg2;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10518 wxString *arg2 = 0 ;
10519 wxString result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 bool temp2 = false ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 {
10547 #if wxUSE_UNICODE
10548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10549 #else
10550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10551 #endif
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *obj;
10569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10571 return SWIG_Py_Void();
10572 }
10573
10574 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10575 return SWIG_Python_InitShadowInstance(args);
10576 }
10577
10578 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxFileSystem *result = 0 ;
10581
10582 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxFileSystem *)new wxFileSystem();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10591 }
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10610 }
10611 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 delete arg1;
10615
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 resultobj = SWIG_Py_Void();
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10629 wxString *arg2 = 0 ;
10630 bool arg3 = (bool) false ;
10631 void *argp1 = 0 ;
10632 int res1 = 0 ;
10633 bool temp2 = false ;
10634 bool val3 ;
10635 int ecode3 = 0 ;
10636 PyObject * obj0 = 0 ;
10637 PyObject * obj1 = 0 ;
10638 PyObject * obj2 = 0 ;
10639 char * kwnames[] = {
10640 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10641 };
10642
10643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10647 }
10648 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10649 {
10650 arg2 = wxString_in_helper(obj1);
10651 if (arg2 == NULL) SWIG_fail;
10652 temp2 = true;
10653 }
10654 if (obj2) {
10655 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10656 if (!SWIG_IsOK(ecode3)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10658 }
10659 arg3 = static_cast< bool >(val3);
10660 }
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 resultobj = SWIG_Py_Void();
10668 {
10669 if (temp2)
10670 delete arg2;
10671 }
10672 return resultobj;
10673 fail:
10674 {
10675 if (temp2)
10676 delete arg2;
10677 }
10678 return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683 PyObject *resultobj = 0;
10684 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10685 wxString result;
10686 void *argp1 = 0 ;
10687 int res1 = 0 ;
10688 PyObject *swig_obj[1] ;
10689
10690 if (!args) SWIG_fail;
10691 swig_obj[0] = args;
10692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10695 }
10696 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 result = (arg1)->GetPath();
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 {
10704 #if wxUSE_UNICODE
10705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10706 #else
10707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10708 #endif
10709 }
10710 return resultobj;
10711 fail:
10712 return NULL;
10713 }
10714
10715
10716 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10717 PyObject *resultobj = 0;
10718 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10719 wxString *arg2 = 0 ;
10720 wxFSFile *result = 0 ;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 bool temp2 = false ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char * kwnames[] = {
10727 (char *) "self",(char *) "location", NULL
10728 };
10729
10730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10732 if (!SWIG_IsOK(res1)) {
10733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10734 }
10735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10736 {
10737 arg2 = wxString_in_helper(obj1);
10738 if (arg2 == NULL) SWIG_fail;
10739 temp2 = true;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 {
10748 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10749 }
10750 {
10751 if (temp2)
10752 delete arg2;
10753 }
10754 return resultobj;
10755 fail:
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return NULL;
10761 }
10762
10763
10764 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj = 0;
10766 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10767 wxString *arg2 = 0 ;
10768 int arg3 = (int) 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 bool temp2 = false ;
10773 int val3 ;
10774 int ecode3 = 0 ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 PyObject * obj2 = 0 ;
10778 char * kwnames[] = {
10779 (char *) "self",(char *) "spec",(char *) "flags", NULL
10780 };
10781
10782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10784 if (!SWIG_IsOK(res1)) {
10785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10786 }
10787 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10788 {
10789 arg2 = wxString_in_helper(obj1);
10790 if (arg2 == NULL) SWIG_fail;
10791 temp2 = true;
10792 }
10793 if (obj2) {
10794 ecode3 = SWIG_AsVal_int(obj2, &val3);
10795 if (!SWIG_IsOK(ecode3)) {
10796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10797 }
10798 arg3 = static_cast< int >(val3);
10799 }
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 {
10814 if (temp2)
10815 delete arg2;
10816 }
10817 return resultobj;
10818 fail:
10819 {
10820 if (temp2)
10821 delete arg2;
10822 }
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10828 PyObject *resultobj = 0;
10829 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10830 wxString result;
10831 void *argp1 = 0 ;
10832 int res1 = 0 ;
10833 PyObject *swig_obj[1] ;
10834
10835 if (!args) SWIG_fail;
10836 swig_obj[0] = args;
10837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10838 if (!SWIG_IsOK(res1)) {
10839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10840 }
10841 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (arg1)->FindNext();
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 #if wxUSE_UNICODE
10850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10851 #else
10852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10853 #endif
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10864 int res1 = 0 ;
10865 PyObject * obj0 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "handler", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10874 }
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 wxFileSystem::AddHandler(arg1);
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_Py_Void();
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 PyObject *resultobj = 0;
10890
10891 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 wxFileSystem::CleanUpHandlers();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_Py_Void();
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxString *arg1 = 0 ;
10908 wxString result;
10909 bool temp1 = false ;
10910 PyObject * obj0 = 0 ;
10911 char * kwnames[] = {
10912 (char *) "filename", NULL
10913 };
10914
10915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10916 {
10917 arg1 = wxString_in_helper(obj0);
10918 if (arg1 == NULL) SWIG_fail;
10919 temp1 = true;
10920 }
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 {
10928 #if wxUSE_UNICODE
10929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10930 #else
10931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10932 #endif
10933 }
10934 {
10935 if (temp1)
10936 delete arg1;
10937 }
10938 return resultobj;
10939 fail:
10940 {
10941 if (temp1)
10942 delete arg1;
10943 }
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxString *arg1 = 0 ;
10951 wxString result;
10952 bool temp1 = false ;
10953 PyObject * obj0 = 0 ;
10954 char * kwnames[] = {
10955 (char *) "url", NULL
10956 };
10957
10958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10959 {
10960 arg1 = wxString_in_helper(obj0);
10961 if (arg1 == NULL) SWIG_fail;
10962 temp1 = true;
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 {
10978 if (temp1)
10979 delete arg1;
10980 }
10981 return resultobj;
10982 fail:
10983 {
10984 if (temp1)
10985 delete arg1;
10986 }
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10992 PyObject *obj;
10993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10994 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10995 return SWIG_Py_Void();
10996 }
10997
10998 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 return SWIG_Python_InitShadowInstance(args);
11000 }
11001
11002 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxInternetFSHandler *result = 0 ;
11005
11006 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11014 return resultobj;
11015 fail:
11016 return NULL;
11017 }
11018
11019
11020 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11021 PyObject *resultobj = 0;
11022 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11023 wxString *arg2 = 0 ;
11024 bool result;
11025 void *argp1 = 0 ;
11026 int res1 = 0 ;
11027 bool temp2 = false ;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 char * kwnames[] = {
11031 (char *) "self",(char *) "location", NULL
11032 };
11033
11034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11036 if (!SWIG_IsOK(res1)) {
11037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11038 }
11039 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11040 {
11041 arg2 = wxString_in_helper(obj1);
11042 if (arg2 == NULL) SWIG_fail;
11043 temp2 = true;
11044 }
11045 {
11046 PyThreadState* __tstate = wxPyBeginAllowThreads();
11047 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 {
11052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11053 }
11054 {
11055 if (temp2)
11056 delete arg2;
11057 }
11058 return resultobj;
11059 fail:
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return NULL;
11065 }
11066
11067
11068 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = 0;
11070 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11071 wxFileSystem *arg2 = 0 ;
11072 wxString *arg3 = 0 ;
11073 wxFSFile *result = 0 ;
11074 void *argp1 = 0 ;
11075 int res1 = 0 ;
11076 void *argp2 = 0 ;
11077 int res2 = 0 ;
11078 bool temp3 = false ;
11079 PyObject * obj0 = 0 ;
11080 PyObject * obj1 = 0 ;
11081 PyObject * obj2 = 0 ;
11082 char * kwnames[] = {
11083 (char *) "self",(char *) "fs",(char *) "location", NULL
11084 };
11085
11086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11090 }
11091 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11093 if (!SWIG_IsOK(res2)) {
11094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11095 }
11096 if (!argp2) {
11097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11098 }
11099 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11100 {
11101 arg3 = wxString_in_helper(obj2);
11102 if (arg3 == NULL) SWIG_fail;
11103 temp3 = true;
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 {
11112 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11113 }
11114 {
11115 if (temp3)
11116 delete arg3;
11117 }
11118 return resultobj;
11119 fail:
11120 {
11121 if (temp3)
11122 delete arg3;
11123 }
11124 return NULL;
11125 }
11126
11127
11128 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11129 PyObject *obj;
11130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11131 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11132 return SWIG_Py_Void();
11133 }
11134
11135 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11136 return SWIG_Python_InitShadowInstance(args);
11137 }
11138
11139 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxZipFSHandler *result = 0 ;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (wxZipFSHandler *)new wxZipFSHandler();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = 0;
11159 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11160 wxString *arg2 = 0 ;
11161 bool result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 bool temp2 = false ;
11165 PyObject * obj0 = 0 ;
11166 PyObject * obj1 = 0 ;
11167 char * kwnames[] = {
11168 (char *) "self",(char *) "location", NULL
11169 };
11170
11171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11175 }
11176 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11177 {
11178 arg2 = wxString_in_helper(obj1);
11179 if (arg2 == NULL) SWIG_fail;
11180 temp2 = true;
11181 }
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11190 }
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj = 0;
11207 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11208 wxFileSystem *arg2 = 0 ;
11209 wxString *arg3 = 0 ;
11210 wxFSFile *result = 0 ;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 void *argp2 = 0 ;
11214 int res2 = 0 ;
11215 bool temp3 = false ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "self",(char *) "fs",(char *) "location", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11225 if (!SWIG_IsOK(res1)) {
11226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11227 }
11228 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11230 if (!SWIG_IsOK(res2)) {
11231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11232 }
11233 if (!argp2) {
11234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11235 }
11236 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11237 {
11238 arg3 = wxString_in_helper(obj2);
11239 if (arg3 == NULL) SWIG_fail;
11240 temp3 = true;
11241 }
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 {
11249 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11250 }
11251 {
11252 if (temp3)
11253 delete arg3;
11254 }
11255 return resultobj;
11256 fail:
11257 {
11258 if (temp3)
11259 delete arg3;
11260 }
11261 return NULL;
11262 }
11263
11264
11265 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11266 PyObject *resultobj = 0;
11267 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11268 wxString *arg2 = 0 ;
11269 int arg3 = (int) 0 ;
11270 wxString result;
11271 void *argp1 = 0 ;
11272 int res1 = 0 ;
11273 bool temp2 = false ;
11274 int val3 ;
11275 int ecode3 = 0 ;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 char * kwnames[] = {
11280 (char *) "self",(char *) "spec",(char *) "flags", NULL
11281 };
11282
11283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11285 if (!SWIG_IsOK(res1)) {
11286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11287 }
11288 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11289 {
11290 arg2 = wxString_in_helper(obj1);
11291 if (arg2 == NULL) SWIG_fail;
11292 temp2 = true;
11293 }
11294 if (obj2) {
11295 ecode3 = SWIG_AsVal_int(obj2, &val3);
11296 if (!SWIG_IsOK(ecode3)) {
11297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11298 }
11299 arg3 = static_cast< int >(val3);
11300 }
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 #if wxUSE_UNICODE
11309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11310 #else
11311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11312 #endif
11313 }
11314 {
11315 if (temp2)
11316 delete arg2;
11317 }
11318 return resultobj;
11319 fail:
11320 {
11321 if (temp2)
11322 delete arg2;
11323 }
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 PyObject *resultobj = 0;
11330 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11331 wxString result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 PyObject *swig_obj[1] ;
11335
11336 if (!args) SWIG_fail;
11337 swig_obj[0] = args;
11338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11339 if (!SWIG_IsOK(res1)) {
11340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11341 }
11342 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (arg1)->FindNext();
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 #if wxUSE_UNICODE
11351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11352 #else
11353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11354 #endif
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11363 PyObject *obj;
11364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11365 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11366 return SWIG_Py_Void();
11367 }
11368
11369 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11370 return SWIG_Python_InitShadowInstance(args);
11371 }
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 wxImage *arg2 = 0 ;
11377 long arg3 ;
11378 bool temp1 = false ;
11379 void *argp2 = 0 ;
11380 int res2 = 0 ;
11381 long val3 ;
11382 int ecode3 = 0 ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 PyObject * obj2 = 0 ;
11386 char * kwnames[] = {
11387 (char *) "filename",(char *) "image",(char *) "type", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11391 {
11392 arg1 = wxString_in_helper(obj0);
11393 if (arg1 == NULL) SWIG_fail;
11394 temp1 = true;
11395 }
11396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11399 }
11400 if (!argp2) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11402 }
11403 arg2 = reinterpret_cast< wxImage * >(argp2);
11404 ecode3 = SWIG_AsVal_long(obj2, &val3);
11405 if (!SWIG_IsOK(ecode3)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11407 }
11408 arg3 = static_cast< long >(val3);
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 resultobj = SWIG_Py_Void();
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 wxBitmap *arg2 = 0 ;
11434 long arg3 ;
11435 bool temp1 = false ;
11436 void *argp2 = 0 ;
11437 int res2 = 0 ;
11438 long val3 ;
11439 int ecode3 = 0 ;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11454 if (!SWIG_IsOK(res2)) {
11455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11456 }
11457 if (!argp2) {
11458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11459 }
11460 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11461 ecode3 = SWIG_AsVal_long(obj2, &val3);
11462 if (!SWIG_IsOK(ecode3)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11464 }
11465 arg3 = static_cast< long >(val3);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return resultobj;
11478 fail:
11479 {
11480 if (temp1)
11481 delete arg1;
11482 }
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 PyObject *arg2 = (PyObject *) 0 ;
11491 bool temp1 = false ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char * kwnames[] = {
11495 (char *) "filename",(char *) "data", NULL
11496 };
11497
11498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11499 {
11500 arg1 = wxString_in_helper(obj0);
11501 if (arg1 == NULL) SWIG_fail;
11502 temp1 = true;
11503 }
11504 arg2 = obj1;
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_Py_Void();
11512 {
11513 if (temp1)
11514 delete arg1;
11515 }
11516 return resultobj;
11517 fail:
11518 {
11519 if (temp1)
11520 delete arg1;
11521 }
11522 return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11527 PyObject *resultobj = 0;
11528 wxMemoryFSHandler *result = 0 ;
11529
11530 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11538 return resultobj;
11539 fail:
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxString *arg1 = 0 ;
11547 bool temp1 = false ;
11548 PyObject * obj0 = 0 ;
11549 char * kwnames[] = {
11550 (char *) "filename", NULL
11551 };
11552
11553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11554 {
11555 arg1 = wxString_in_helper(obj0);
11556 if (arg1 == NULL) SWIG_fail;
11557 temp1 = true;
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_Py_Void();
11566 {
11567 if (temp1)
11568 delete arg1;
11569 }
11570 return resultobj;
11571 fail:
11572 {
11573 if (temp1)
11574 delete arg1;
11575 }
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj = 0;
11582 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11583 wxString *arg2 = 0 ;
11584 bool result;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 bool temp2 = false ;
11588 PyObject * obj0 = 0 ;
11589 PyObject * obj1 = 0 ;
11590 char * kwnames[] = {
11591 (char *) "self",(char *) "location", NULL
11592 };
11593
11594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11598 }
11599 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11600 {
11601 arg2 = wxString_in_helper(obj1);
11602 if (arg2 == NULL) SWIG_fail;
11603 temp2 = true;
11604 }
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 {
11612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11613 }
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return NULL;
11625 }
11626
11627
11628 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj = 0;
11630 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11631 wxFileSystem *arg2 = 0 ;
11632 wxString *arg3 = 0 ;
11633 wxFSFile *result = 0 ;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 void *argp2 = 0 ;
11637 int res2 = 0 ;
11638 bool temp3 = false ;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 PyObject * obj2 = 0 ;
11642 char * kwnames[] = {
11643 (char *) "self",(char *) "fs",(char *) "location", NULL
11644 };
11645
11646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11653 if (!SWIG_IsOK(res2)) {
11654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11655 }
11656 if (!argp2) {
11657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11658 }
11659 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11660 {
11661 arg3 = wxString_in_helper(obj2);
11662 if (arg3 == NULL) SWIG_fail;
11663 temp3 = true;
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11673 }
11674 {
11675 if (temp3)
11676 delete arg3;
11677 }
11678 return resultobj;
11679 fail:
11680 {
11681 if (temp3)
11682 delete arg3;
11683 }
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11691 wxString *arg2 = 0 ;
11692 int arg3 = (int) 0 ;
11693 wxString result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 bool temp2 = false ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "spec",(char *) "flags", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11710 }
11711 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11712 {
11713 arg2 = wxString_in_helper(obj1);
11714 if (arg2 == NULL) SWIG_fail;
11715 temp2 = true;
11716 }
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 {
11738 if (temp2)
11739 delete arg2;
11740 }
11741 return resultobj;
11742 fail:
11743 {
11744 if (temp2)
11745 delete arg2;
11746 }
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11754 wxString result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11764 }
11765 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (arg1)->FindNext();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 #if wxUSE_UNICODE
11774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11775 #else
11776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11777 #endif
11778 }
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11786 PyObject *obj;
11787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11788 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11789 return SWIG_Py_Void();
11790 }
11791
11792 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 return SWIG_Python_InitShadowInstance(args);
11794 }
11795
11796 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11797 PyObject *resultobj = 0;
11798 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11799 wxString result;
11800 void *argp1 = 0 ;
11801 int res1 = 0 ;
11802 PyObject *swig_obj[1] ;
11803
11804 if (!args) SWIG_fail;
11805 swig_obj[0] = args;
11806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11807 if (!SWIG_IsOK(res1)) {
11808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11809 }
11810 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (arg1)->GetName();
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 #if wxUSE_UNICODE
11819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11820 #else
11821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11822 #endif
11823 }
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11833 wxString result;
11834 void *argp1 = 0 ;
11835 int res1 = 0 ;
11836 PyObject *swig_obj[1] ;
11837
11838 if (!args) SWIG_fail;
11839 swig_obj[0] = args;
11840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11841 if (!SWIG_IsOK(res1)) {
11842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11843 }
11844 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (arg1)->GetExtension();
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 #if wxUSE_UNICODE
11853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11854 #else
11855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11856 #endif
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11867 long result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (long)(arg1)->GetType();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 resultobj = SWIG_From_long(static_cast< long >(result));
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *resultobj = 0;
11894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11895 wxString result;
11896 void *argp1 = 0 ;
11897 int res1 = 0 ;
11898 PyObject *swig_obj[1] ;
11899
11900 if (!args) SWIG_fail;
11901 swig_obj[0] = args;
11902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11905 }
11906 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (arg1)->GetMimeType();
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 #if wxUSE_UNICODE
11915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11916 #else
11917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11918 #endif
11919 }
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj = 0;
11928 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11929 wxString *arg2 = 0 ;
11930 bool result;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 bool temp2 = false ;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "name", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11944 }
11945 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11946 {
11947 arg2 = wxString_in_helper(obj1);
11948 if (arg2 == NULL) SWIG_fail;
11949 temp2 = true;
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (temp2)
11962 delete arg2;
11963 }
11964 return resultobj;
11965 fail:
11966 {
11967 if (temp2)
11968 delete arg2;
11969 }
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = 0;
11976 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11977 wxInputStream *arg2 = 0 ;
11978 bool result;
11979 void *argp1 = 0 ;
11980 int res1 = 0 ;
11981 wxPyInputStream *temp2 ;
11982 bool created2 ;
11983 PyObject * obj0 = 0 ;
11984 PyObject * obj1 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "self",(char *) "stream", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11993 }
11994 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11995 {
11996 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11997 arg2 = temp2->m_wxis;
11998 created2 = false;
11999 } else {
12000 PyErr_Clear(); // clear the failure of the wxPyConvert above
12001 arg2 = wxPyCBInputStream_create(obj1, false);
12002 if (arg2 == NULL) {
12003 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12004 SWIG_fail;
12005 }
12006 created2 = true;
12007 }
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead(*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (created2) delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (created2) delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj = 0;
12032 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12033 wxString *arg2 = 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 bool temp2 = false ;
12037 PyObject * obj0 = 0 ;
12038 PyObject * obj1 = 0 ;
12039 char * kwnames[] = {
12040 (char *) "self",(char *) "name", NULL
12041 };
12042
12043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12045 if (!SWIG_IsOK(res1)) {
12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12047 }
12048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12049 {
12050 arg2 = wxString_in_helper(obj1);
12051 if (arg2 == NULL) SWIG_fail;
12052 temp2 = true;
12053 }
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 (arg1)->SetName((wxString const &)*arg2);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_Py_Void();
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj = 0;
12077 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12078 wxString *arg2 = 0 ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 bool temp2 = false ;
12082 PyObject * obj0 = 0 ;
12083 PyObject * obj1 = 0 ;
12084 char * kwnames[] = {
12085 (char *) "self",(char *) "extension", NULL
12086 };
12087
12088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12092 }
12093 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12094 {
12095 arg2 = wxString_in_helper(obj1);
12096 if (arg2 == NULL) SWIG_fail;
12097 temp2 = true;
12098 }
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 (arg1)->SetExtension((wxString const &)*arg2);
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 resultobj = SWIG_Py_Void();
12106 {
12107 if (temp2)
12108 delete arg2;
12109 }
12110 return resultobj;
12111 fail:
12112 {
12113 if (temp2)
12114 delete arg2;
12115 }
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj = 0;
12122 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12123 long arg2 ;
12124 void *argp1 = 0 ;
12125 int res1 = 0 ;
12126 long val2 ;
12127 int ecode2 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "self",(char *) "type", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12138 }
12139 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12140 ecode2 = SWIG_AsVal_long(obj1, &val2);
12141 if (!SWIG_IsOK(ecode2)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12143 }
12144 arg2 = static_cast< long >(val2);
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 (arg1)->SetType(arg2);
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 resultobj = SWIG_Py_Void();
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12161 wxString *arg2 = 0 ;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 bool temp2 = false ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 char * kwnames[] = {
12168 (char *) "self",(char *) "mimetype", NULL
12169 };
12170
12171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12173 if (!SWIG_IsOK(res1)) {
12174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12175 }
12176 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12177 {
12178 arg2 = wxString_in_helper(obj1);
12179 if (arg2 == NULL) SWIG_fail;
12180 temp2 = true;
12181 }
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 (arg1)->SetMimeType((wxString const &)*arg2);
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 resultobj = SWIG_Py_Void();
12189 {
12190 if (temp2)
12191 delete arg2;
12192 }
12193 return resultobj;
12194 fail:
12195 {
12196 if (temp2)
12197 delete arg2;
12198 }
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *obj;
12205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12206 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 PyObject *resultobj = 0;
12212 wxPyImageHandler *result = 0 ;
12213
12214 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (wxPyImageHandler *)new wxPyImageHandler();
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12231 PyObject *arg2 = (PyObject *) 0 ;
12232 void *argp1 = 0 ;
12233 int res1 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "self",(char *) "self", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12244 }
12245 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12246 arg2 = obj1;
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 (arg1)->_SetSelf(arg2);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 resultobj = SWIG_Py_Void();
12254 return resultobj;
12255 fail:
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12261 PyObject *obj;
12262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12263 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12264 return SWIG_Py_Void();
12265 }
12266
12267 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12268 return SWIG_Python_InitShadowInstance(args);
12269 }
12270
12271 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxImageHistogram *result = 0 ;
12274
12275 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (wxImageHistogram *)new wxImageHistogram();
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 byte arg1 ;
12292 byte arg2 ;
12293 byte arg3 ;
12294 unsigned long result;
12295 unsigned char val1 ;
12296 int ecode1 = 0 ;
12297 unsigned char val2 ;
12298 int ecode2 = 0 ;
12299 unsigned char val3 ;
12300 int ecode3 = 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 PyObject * obj2 = 0 ;
12304 char * kwnames[] = {
12305 (char *) "r",(char *) "g",(char *) "b", NULL
12306 };
12307
12308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12309 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12310 if (!SWIG_IsOK(ecode1)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12312 }
12313 arg1 = static_cast< byte >(val1);
12314 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12315 if (!SWIG_IsOK(ecode2)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12317 }
12318 arg2 = static_cast< byte >(val2);
12319 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12320 if (!SWIG_IsOK(ecode3)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12322 }
12323 arg3 = static_cast< byte >(val3);
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12340 byte *arg2 = (byte *) 0 ;
12341 byte *arg3 = (byte *) 0 ;
12342 byte *arg4 = (byte *) 0 ;
12343 byte arg5 = (byte) 1 ;
12344 byte arg6 = (byte) 0 ;
12345 byte arg7 = (byte) 0 ;
12346 bool result;
12347 void *argp1 = 0 ;
12348 int res1 = 0 ;
12349 byte temp2 ;
12350 int res2 = SWIG_TMPOBJ ;
12351 byte temp3 ;
12352 int res3 = SWIG_TMPOBJ ;
12353 byte temp4 ;
12354 int res4 = SWIG_TMPOBJ ;
12355 unsigned char val5 ;
12356 int ecode5 = 0 ;
12357 unsigned char val6 ;
12358 int ecode6 = 0 ;
12359 unsigned char val7 ;
12360 int ecode7 = 0 ;
12361 PyObject * obj0 = 0 ;
12362 PyObject * obj1 = 0 ;
12363 PyObject * obj2 = 0 ;
12364 PyObject * obj3 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12367 };
12368
12369 arg2 = &temp2;
12370 arg3 = &temp3;
12371 arg4 = &temp4;
12372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12374 if (!SWIG_IsOK(res1)) {
12375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12376 }
12377 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12378 if (obj1) {
12379 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12380 if (!SWIG_IsOK(ecode5)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12382 }
12383 arg5 = static_cast< byte >(val5);
12384 }
12385 if (obj2) {
12386 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12387 if (!SWIG_IsOK(ecode6)) {
12388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12389 }
12390 arg6 = static_cast< byte >(val6);
12391 }
12392 if (obj3) {
12393 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12394 if (!SWIG_IsOK(ecode7)) {
12395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12396 }
12397 arg7 = static_cast< byte >(val7);
12398 }
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12407 }
12408 if (SWIG_IsTmpObj(res2)) {
12409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12410 } else {
12411 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12413 }
12414 if (SWIG_IsTmpObj(res3)) {
12415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12416 } else {
12417 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12419 }
12420 if (SWIG_IsTmpObj(res4)) {
12421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12422 } else {
12423 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj = 0;
12434 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12435 unsigned long arg2 ;
12436 unsigned long result;
12437 void *argp1 = 0 ;
12438 int res1 = 0 ;
12439 unsigned long val2 ;
12440 int ecode2 = 0 ;
12441 PyObject * obj0 = 0 ;
12442 PyObject * obj1 = 0 ;
12443 char * kwnames[] = {
12444 (char *) "self",(char *) "key", NULL
12445 };
12446
12447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12449 if (!SWIG_IsOK(res1)) {
12450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12451 }
12452 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12453 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12454 if (!SWIG_IsOK(ecode2)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12456 }
12457 arg2 = static_cast< unsigned long >(val2);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12474 byte arg2 ;
12475 byte arg3 ;
12476 byte arg4 ;
12477 unsigned long result;
12478 void *argp1 = 0 ;
12479 int res1 = 0 ;
12480 unsigned char val2 ;
12481 int ecode2 = 0 ;
12482 unsigned char val3 ;
12483 int ecode3 = 0 ;
12484 unsigned char val4 ;
12485 int ecode4 = 0 ;
12486 PyObject * obj0 = 0 ;
12487 PyObject * obj1 = 0 ;
12488 PyObject * obj2 = 0 ;
12489 PyObject * obj3 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12496 if (!SWIG_IsOK(res1)) {
12497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12498 }
12499 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12500 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12501 if (!SWIG_IsOK(ecode2)) {
12502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12503 }
12504 arg2 = static_cast< byte >(val2);
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12511 if (!SWIG_IsOK(ecode4)) {
12512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12513 }
12514 arg4 = static_cast< byte >(val4);
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12531 wxColour *arg2 = 0 ;
12532 unsigned long result;
12533 void *argp1 = 0 ;
12534 int res1 = 0 ;
12535 wxColour temp2 ;
12536 PyObject * obj0 = 0 ;
12537 PyObject * obj1 = 0 ;
12538 char * kwnames[] = {
12539 (char *) "self",(char *) "colour", NULL
12540 };
12541
12542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12544 if (!SWIG_IsOK(res1)) {
12545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12546 }
12547 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12548 {
12549 arg2 = &temp2;
12550 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12551 }
12552 {
12553 PyThreadState* __tstate = wxPyBeginAllowThreads();
12554 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *obj;
12567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12568 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12569 return SWIG_Py_Void();
12570 }
12571
12572 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 return SWIG_Python_InitShadowInstance(args);
12574 }
12575
12576 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12577 PyObject *resultobj = 0;
12578 byte arg1 = (byte) 0 ;
12579 byte arg2 = (byte) 0 ;
12580 byte arg3 = (byte) 0 ;
12581 wxImage_RGBValue *result = 0 ;
12582 unsigned char val1 ;
12583 int ecode1 = 0 ;
12584 unsigned char val2 ;
12585 int ecode2 = 0 ;
12586 unsigned char val3 ;
12587 int ecode3 = 0 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 PyObject * obj2 = 0 ;
12591 char * kwnames[] = {
12592 (char *) "r",(char *) "g",(char *) "b", NULL
12593 };
12594
12595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12596 if (obj0) {
12597 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12598 if (!SWIG_IsOK(ecode1)) {
12599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12600 }
12601 arg1 = static_cast< byte >(val1);
12602 }
12603 if (obj1) {
12604 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12605 if (!SWIG_IsOK(ecode2)) {
12606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12607 }
12608 arg2 = static_cast< byte >(val2);
12609 }
12610 if (obj2) {
12611 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12612 if (!SWIG_IsOK(ecode3)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12614 }
12615 arg3 = static_cast< byte >(val3);
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 PyObject *resultobj = 0;
12632 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12633 byte arg2 ;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 unsigned char val2 ;
12637 int ecode2 = 0 ;
12638 PyObject *swig_obj[2] ;
12639
12640 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12644 }
12645 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12646 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12647 if (!SWIG_IsOK(ecode2)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 if (arg1) (arg1)->red = arg2;
12652
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12663 byte result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 if (!args) SWIG_fail;
12669 swig_obj[0] = args;
12670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12671 if (!SWIG_IsOK(res1)) {
12672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12673 }
12674 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12675 result = (byte) ((arg1)->red);
12676 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12686 byte arg2 ;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 unsigned char val2 ;
12690 int ecode2 = 0 ;
12691 PyObject *swig_obj[2] ;
12692
12693 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12697 }
12698 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12699 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12702 }
12703 arg2 = static_cast< byte >(val2);
12704 if (arg1) (arg1)->green = arg2;
12705
12706 resultobj = SWIG_Py_Void();
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12714 PyObject *resultobj = 0;
12715 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12716 byte result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject *swig_obj[1] ;
12720
12721 if (!args) SWIG_fail;
12722 swig_obj[0] = args;
12723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12724 if (!SWIG_IsOK(res1)) {
12725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12726 }
12727 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12728 result = (byte) ((arg1)->green);
12729 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12739 byte arg2 ;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 unsigned char val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12748 if (!SWIG_IsOK(res1)) {
12749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12750 }
12751 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12752 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12753 if (!SWIG_IsOK(ecode2)) {
12754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12755 }
12756 arg2 = static_cast< byte >(val2);
12757 if (arg1) (arg1)->blue = arg2;
12758
12759 resultobj = SWIG_Py_Void();
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12769 byte result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 PyObject *swig_obj[1] ;
12773
12774 if (!args) SWIG_fail;
12775 swig_obj[0] = args;
12776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12779 }
12780 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12781 result = (byte) ((arg1)->blue);
12782 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *obj;
12791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12792 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12793 return SWIG_Py_Void();
12794 }
12795
12796 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 return SWIG_Python_InitShadowInstance(args);
12798 }
12799
12800 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj = 0;
12802 double arg1 = (double) 0.0 ;
12803 double arg2 = (double) 0.0 ;
12804 double arg3 = (double) 0.0 ;
12805 wxImage_HSVValue *result = 0 ;
12806 double val1 ;
12807 int ecode1 = 0 ;
12808 double val2 ;
12809 int ecode2 = 0 ;
12810 double val3 ;
12811 int ecode3 = 0 ;
12812 PyObject * obj0 = 0 ;
12813 PyObject * obj1 = 0 ;
12814 PyObject * obj2 = 0 ;
12815 char * kwnames[] = {
12816 (char *) "h",(char *) "s",(char *) "v", NULL
12817 };
12818
12819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12820 if (obj0) {
12821 ecode1 = SWIG_AsVal_double(obj0, &val1);
12822 if (!SWIG_IsOK(ecode1)) {
12823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12824 }
12825 arg1 = static_cast< double >(val1);
12826 }
12827 if (obj1) {
12828 ecode2 = SWIG_AsVal_double(obj1, &val2);
12829 if (!SWIG_IsOK(ecode2)) {
12830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12831 }
12832 arg2 = static_cast< double >(val2);
12833 }
12834 if (obj2) {
12835 ecode3 = SWIG_AsVal_double(obj2, &val3);
12836 if (!SWIG_IsOK(ecode3)) {
12837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12838 }
12839 arg3 = static_cast< double >(val3);
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12857 double arg2 ;
12858 void *argp1 = 0 ;
12859 int res1 = 0 ;
12860 double val2 ;
12861 int ecode2 = 0 ;
12862 PyObject *swig_obj[2] ;
12863
12864 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12868 }
12869 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12870 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 if (arg1) (arg1)->hue = arg2;
12876
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12885 PyObject *resultobj = 0;
12886 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12887 double result;
12888 void *argp1 = 0 ;
12889 int res1 = 0 ;
12890 PyObject *swig_obj[1] ;
12891
12892 if (!args) SWIG_fail;
12893 swig_obj[0] = args;
12894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12895 if (!SWIG_IsOK(res1)) {
12896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12897 }
12898 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12899 result = (double) ((arg1)->hue);
12900 resultobj = SWIG_From_double(static_cast< double >(result));
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12910 double arg2 ;
12911 void *argp1 = 0 ;
12912 int res1 = 0 ;
12913 double val2 ;
12914 int ecode2 = 0 ;
12915 PyObject *swig_obj[2] ;
12916
12917 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12919 if (!SWIG_IsOK(res1)) {
12920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12921 }
12922 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12923 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12924 if (!SWIG_IsOK(ecode2)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12926 }
12927 arg2 = static_cast< double >(val2);
12928 if (arg1) (arg1)->saturation = arg2;
12929
12930 resultobj = SWIG_Py_Void();
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12940 double result;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject *swig_obj[1] ;
12944
12945 if (!args) SWIG_fail;
12946 swig_obj[0] = args;
12947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12950 }
12951 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12952 result = (double) ((arg1)->saturation);
12953 resultobj = SWIG_From_double(static_cast< double >(result));
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *resultobj = 0;
12962 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12963 double arg2 ;
12964 void *argp1 = 0 ;
12965 int res1 = 0 ;
12966 double val2 ;
12967 int ecode2 = 0 ;
12968 PyObject *swig_obj[2] ;
12969
12970 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12974 }
12975 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12976 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12977 if (!SWIG_IsOK(ecode2)) {
12978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12979 }
12980 arg2 = static_cast< double >(val2);
12981 if (arg1) (arg1)->value = arg2;
12982
12983 resultobj = SWIG_Py_Void();
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *resultobj = 0;
12992 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12993 double result;
12994 void *argp1 = 0 ;
12995 int res1 = 0 ;
12996 PyObject *swig_obj[1] ;
12997
12998 if (!args) SWIG_fail;
12999 swig_obj[0] = args;
13000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13001 if (!SWIG_IsOK(res1)) {
13002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13003 }
13004 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13005 result = (double) ((arg1)->value);
13006 resultobj = SWIG_From_double(static_cast< double >(result));
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13014 PyObject *obj;
13015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13016 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13017 return SWIG_Py_Void();
13018 }
13019
13020 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13021 return SWIG_Python_InitShadowInstance(args);
13022 }
13023
13024 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj = 0;
13026 wxString *arg1 = 0 ;
13027 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13028 int arg3 = (int) -1 ;
13029 wxImage *result = 0 ;
13030 bool temp1 = false ;
13031 long val2 ;
13032 int ecode2 = 0 ;
13033 int val3 ;
13034 int ecode3 = 0 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 PyObject * obj2 = 0 ;
13038 char * kwnames[] = {
13039 (char *) "name",(char *) "type",(char *) "index", NULL
13040 };
13041
13042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13043 {
13044 arg1 = wxString_in_helper(obj0);
13045 if (arg1 == NULL) SWIG_fail;
13046 temp1 = true;
13047 }
13048 if (obj1) {
13049 ecode2 = SWIG_AsVal_long(obj1, &val2);
13050 if (!SWIG_IsOK(ecode2)) {
13051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13052 }
13053 arg2 = static_cast< long >(val2);
13054 }
13055 if (obj2) {
13056 ecode3 = SWIG_AsVal_int(obj2, &val3);
13057 if (!SWIG_IsOK(ecode3)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13059 }
13060 arg3 = static_cast< int >(val3);
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13069 {
13070 if (temp1)
13071 delete arg1;
13072 }
13073 return resultobj;
13074 fail:
13075 {
13076 if (temp1)
13077 delete arg1;
13078 }
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 void *argp1 = 0 ;
13087 int res1 = 0 ;
13088 PyObject *swig_obj[1] ;
13089
13090 if (!args) SWIG_fail;
13091 swig_obj[0] = args;
13092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13093 if (!SWIG_IsOK(res1)) {
13094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13095 }
13096 arg1 = reinterpret_cast< wxImage * >(argp1);
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 delete arg1;
13100
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_Py_Void();
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj = 0;
13113 wxString *arg1 = 0 ;
13114 wxString *arg2 = 0 ;
13115 int arg3 = (int) -1 ;
13116 wxImage *result = 0 ;
13117 bool temp1 = false ;
13118 bool temp2 = false ;
13119 int val3 ;
13120 int ecode3 = 0 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 char * kwnames[] = {
13125 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13126 };
13127
13128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13129 {
13130 arg1 = wxString_in_helper(obj0);
13131 if (arg1 == NULL) SWIG_fail;
13132 temp1 = true;
13133 }
13134 {
13135 arg2 = wxString_in_helper(obj1);
13136 if (arg2 == NULL) SWIG_fail;
13137 temp2 = true;
13138 }
13139 if (obj2) {
13140 ecode3 = SWIG_AsVal_int(obj2, &val3);
13141 if (!SWIG_IsOK(ecode3)) {
13142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13143 }
13144 arg3 = static_cast< int >(val3);
13145 }
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13153 {
13154 if (temp1)
13155 delete arg1;
13156 }
13157 {
13158 if (temp2)
13159 delete arg2;
13160 }
13161 return resultobj;
13162 fail:
13163 {
13164 if (temp1)
13165 delete arg1;
13166 }
13167 {
13168 if (temp2)
13169 delete arg2;
13170 }
13171 return NULL;
13172 }
13173
13174
13175 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj = 0;
13177 wxInputStream *arg1 = 0 ;
13178 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13179 int arg3 = (int) -1 ;
13180 wxImage *result = 0 ;
13181 wxPyInputStream *temp1 ;
13182 bool created1 ;
13183 long val2 ;
13184 int ecode2 = 0 ;
13185 int val3 ;
13186 int ecode3 = 0 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "stream",(char *) "type",(char *) "index", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 {
13196 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13197 arg1 = temp1->m_wxis;
13198 created1 = false;
13199 } else {
13200 PyErr_Clear(); // clear the failure of the wxPyConvert above
13201 arg1 = wxPyCBInputStream_create(obj0, false);
13202 if (arg1 == NULL) {
13203 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13204 SWIG_fail;
13205 }
13206 created1 = true;
13207 }
13208 }
13209 if (obj1) {
13210 ecode2 = SWIG_AsVal_long(obj1, &val2);
13211 if (!SWIG_IsOK(ecode2)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13213 }
13214 arg2 = static_cast< long >(val2);
13215 }
13216 if (obj2) {
13217 ecode3 = SWIG_AsVal_int(obj2, &val3);
13218 if (!SWIG_IsOK(ecode3)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13220 }
13221 arg3 = static_cast< int >(val3);
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13230 {
13231 if (created1) delete arg1;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (created1) delete arg1;
13237 }
13238 return NULL;
13239 }
13240
13241
13242 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj = 0;
13244 wxInputStream *arg1 = 0 ;
13245 wxString *arg2 = 0 ;
13246 int arg3 = (int) -1 ;
13247 wxImage *result = 0 ;
13248 wxPyInputStream *temp1 ;
13249 bool created1 ;
13250 bool temp2 = false ;
13251 int val3 ;
13252 int ecode3 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13261 {
13262 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13263 arg1 = temp1->m_wxis;
13264 created1 = false;
13265 } else {
13266 PyErr_Clear(); // clear the failure of the wxPyConvert above
13267 arg1 = wxPyCBInputStream_create(obj0, false);
13268 if (arg1 == NULL) {
13269 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13270 SWIG_fail;
13271 }
13272 created1 = true;
13273 }
13274 }
13275 {
13276 arg2 = wxString_in_helper(obj1);
13277 if (arg2 == NULL) SWIG_fail;
13278 temp2 = true;
13279 }
13280 if (obj2) {
13281 ecode3 = SWIG_AsVal_int(obj2, &val3);
13282 if (!SWIG_IsOK(ecode3)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13284 }
13285 arg3 = static_cast< int >(val3);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13294 {
13295 if (created1) delete arg1;
13296 }
13297 {
13298 if (temp2)
13299 delete arg2;
13300 }
13301 return resultobj;
13302 fail:
13303 {
13304 if (created1) delete arg1;
13305 }
13306 {
13307 if (temp2)
13308 delete arg2;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj = 0;
13316 int arg1 = (int) 0 ;
13317 int arg2 = (int) 0 ;
13318 bool arg3 = (bool) true ;
13319 wxImage *result = 0 ;
13320 int val1 ;
13321 int ecode1 = 0 ;
13322 int val2 ;
13323 int ecode2 = 0 ;
13324 bool val3 ;
13325 int ecode3 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 char * kwnames[] = {
13330 (char *) "width",(char *) "height",(char *) "clear", NULL
13331 };
13332
13333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13334 if (obj0) {
13335 ecode1 = SWIG_AsVal_int(obj0, &val1);
13336 if (!SWIG_IsOK(ecode1)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13338 }
13339 arg1 = static_cast< int >(val1);
13340 }
13341 if (obj1) {
13342 ecode2 = SWIG_AsVal_int(obj1, &val2);
13343 if (!SWIG_IsOK(ecode2)) {
13344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13345 }
13346 arg2 = static_cast< int >(val2);
13347 }
13348 if (obj2) {
13349 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13350 if (!SWIG_IsOK(ecode3)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13352 }
13353 arg3 = static_cast< bool >(val3);
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13369 PyObject *resultobj = 0;
13370 wxBitmap *arg1 = 0 ;
13371 wxImage *result = 0 ;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 PyObject * obj0 = 0 ;
13375 char * kwnames[] = {
13376 (char *) "bitmap", NULL
13377 };
13378
13379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13380 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13381 if (!SWIG_IsOK(res1)) {
13382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13383 }
13384 if (!argp1) {
13385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13386 }
13387 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13388 {
13389 if (!wxPyCheckForApp()) SWIG_fail;
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj = 0;
13404 int arg1 ;
13405 int arg2 ;
13406 buffer arg3 ;
13407 int arg4 ;
13408 wxImage *result = 0 ;
13409 int val1 ;
13410 int ecode1 = 0 ;
13411 int val2 ;
13412 int ecode2 = 0 ;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 PyObject * obj2 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "width",(char *) "height",(char *) "data", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13421 ecode1 = SWIG_AsVal_int(obj0, &val1);
13422 if (!SWIG_IsOK(ecode1)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13424 }
13425 arg1 = static_cast< int >(val1);
13426 ecode2 = SWIG_AsVal_int(obj1, &val2);
13427 if (!SWIG_IsOK(ecode2)) {
13428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13429 }
13430 arg2 = static_cast< int >(val2);
13431 {
13432 if (obj2 != Py_None) {
13433 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13434 }
13435 }
13436 {
13437 PyThreadState* __tstate = wxPyBeginAllowThreads();
13438 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13439 wxPyEndAllowThreads(__tstate);
13440 if (PyErr_Occurred()) SWIG_fail;
13441 }
13442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13443 return resultobj;
13444 fail:
13445 return NULL;
13446 }
13447
13448
13449 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13450 PyObject *resultobj = 0;
13451 int arg1 ;
13452 int arg2 ;
13453 buffer arg3 ;
13454 int arg4 ;
13455 buffer arg5 ;
13456 int arg6 ;
13457 wxImage *result = 0 ;
13458 int val1 ;
13459 int ecode1 = 0 ;
13460 int val2 ;
13461 int ecode2 = 0 ;
13462 PyObject * obj0 = 0 ;
13463 PyObject * obj1 = 0 ;
13464 PyObject * obj2 = 0 ;
13465 PyObject * obj3 = 0 ;
13466 char * kwnames[] = {
13467 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13468 };
13469
13470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13471 ecode1 = SWIG_AsVal_int(obj0, &val1);
13472 if (!SWIG_IsOK(ecode1)) {
13473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13474 }
13475 arg1 = static_cast< int >(val1);
13476 ecode2 = SWIG_AsVal_int(obj1, &val2);
13477 if (!SWIG_IsOK(ecode2)) {
13478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13479 }
13480 arg2 = static_cast< int >(val2);
13481 {
13482 if (obj2 != Py_None) {
13483 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13484 }
13485 }
13486 {
13487 if (obj3 != Py_None) {
13488 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13489 }
13490 }
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13498 return resultobj;
13499 fail:
13500 return NULL;
13501 }
13502
13503
13504 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj = 0;
13506 wxImage *arg1 = (wxImage *) 0 ;
13507 int arg2 ;
13508 int arg3 ;
13509 bool arg4 = (bool) true ;
13510 void *argp1 = 0 ;
13511 int res1 = 0 ;
13512 int val2 ;
13513 int ecode2 = 0 ;
13514 int val3 ;
13515 int ecode3 = 0 ;
13516 bool val4 ;
13517 int ecode4 = 0 ;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 PyObject * obj2 = 0 ;
13521 PyObject * obj3 = 0 ;
13522 char * kwnames[] = {
13523 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13524 };
13525
13526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13528 if (!SWIG_IsOK(res1)) {
13529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13530 }
13531 arg1 = reinterpret_cast< wxImage * >(argp1);
13532 ecode2 = SWIG_AsVal_int(obj1, &val2);
13533 if (!SWIG_IsOK(ecode2)) {
13534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13535 }
13536 arg2 = static_cast< int >(val2);
13537 ecode3 = SWIG_AsVal_int(obj2, &val3);
13538 if (!SWIG_IsOK(ecode3)) {
13539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13540 }
13541 arg3 = static_cast< int >(val3);
13542 if (obj3) {
13543 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13544 if (!SWIG_IsOK(ecode4)) {
13545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13546 }
13547 arg4 = static_cast< bool >(val4);
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 (arg1)->Create(arg2,arg3,arg4);
13552 wxPyEndAllowThreads(__tstate);
13553 if (PyErr_Occurred()) SWIG_fail;
13554 }
13555 resultobj = SWIG_Py_Void();
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13563 PyObject *resultobj = 0;
13564 wxImage *arg1 = (wxImage *) 0 ;
13565 void *argp1 = 0 ;
13566 int res1 = 0 ;
13567 PyObject *swig_obj[1] ;
13568
13569 if (!args) SWIG_fail;
13570 swig_obj[0] = args;
13571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13572 if (!SWIG_IsOK(res1)) {
13573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13574 }
13575 arg1 = reinterpret_cast< wxImage * >(argp1);
13576 {
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 (arg1)->Destroy();
13579 wxPyEndAllowThreads(__tstate);
13580 if (PyErr_Occurred()) SWIG_fail;
13581 }
13582 resultobj = SWIG_Py_Void();
13583 return resultobj;
13584 fail:
13585 return NULL;
13586 }
13587
13588
13589 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13590 PyObject *resultobj = 0;
13591 wxImage *arg1 = (wxImage *) 0 ;
13592 int arg2 ;
13593 int arg3 ;
13594 SwigValueWrapper<wxImage > result;
13595 void *argp1 = 0 ;
13596 int res1 = 0 ;
13597 int val2 ;
13598 int ecode2 = 0 ;
13599 int val3 ;
13600 int ecode3 = 0 ;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 PyObject * obj2 = 0 ;
13604 char * kwnames[] = {
13605 (char *) "self",(char *) "width",(char *) "height", NULL
13606 };
13607
13608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13610 if (!SWIG_IsOK(res1)) {
13611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13612 }
13613 arg1 = reinterpret_cast< wxImage * >(argp1);
13614 ecode2 = SWIG_AsVal_int(obj1, &val2);
13615 if (!SWIG_IsOK(ecode2)) {
13616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13617 }
13618 arg2 = static_cast< int >(val2);
13619 ecode3 = SWIG_AsVal_int(obj2, &val3);
13620 if (!SWIG_IsOK(ecode3)) {
13621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13622 }
13623 arg3 = static_cast< int >(val3);
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 result = (arg1)->Scale(arg2,arg3);
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj = 0;
13639 wxImage *arg1 = (wxImage *) 0 ;
13640 int arg2 ;
13641 int arg3 ;
13642 SwigValueWrapper<wxImage > result;
13643 void *argp1 = 0 ;
13644 int res1 = 0 ;
13645 int val2 ;
13646 int ecode2 = 0 ;
13647 int val3 ;
13648 int ecode3 = 0 ;
13649 PyObject * obj0 = 0 ;
13650 PyObject * obj1 = 0 ;
13651 PyObject * obj2 = 0 ;
13652 char * kwnames[] = {
13653 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13654 };
13655
13656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13658 if (!SWIG_IsOK(res1)) {
13659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13660 }
13661 arg1 = reinterpret_cast< wxImage * >(argp1);
13662 ecode2 = SWIG_AsVal_int(obj1, &val2);
13663 if (!SWIG_IsOK(ecode2)) {
13664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13665 }
13666 arg2 = static_cast< int >(val2);
13667 ecode3 = SWIG_AsVal_int(obj2, &val3);
13668 if (!SWIG_IsOK(ecode3)) {
13669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13670 }
13671 arg3 = static_cast< int >(val3);
13672 {
13673 PyThreadState* __tstate = wxPyBeginAllowThreads();
13674 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13675 wxPyEndAllowThreads(__tstate);
13676 if (PyErr_Occurred()) SWIG_fail;
13677 }
13678 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13679 return resultobj;
13680 fail:
13681 return NULL;
13682 }
13683
13684
13685 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13686 PyObject *resultobj = 0;
13687 wxImage *arg1 = (wxImage *) 0 ;
13688 int arg2 ;
13689 int arg3 ;
13690 wxImage *result = 0 ;
13691 void *argp1 = 0 ;
13692 int res1 = 0 ;
13693 int val2 ;
13694 int ecode2 = 0 ;
13695 int val3 ;
13696 int ecode3 = 0 ;
13697 PyObject * obj0 = 0 ;
13698 PyObject * obj1 = 0 ;
13699 PyObject * obj2 = 0 ;
13700 char * kwnames[] = {
13701 (char *) "self",(char *) "width",(char *) "height", NULL
13702 };
13703
13704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13706 if (!SWIG_IsOK(res1)) {
13707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13708 }
13709 arg1 = reinterpret_cast< wxImage * >(argp1);
13710 ecode2 = SWIG_AsVal_int(obj1, &val2);
13711 if (!SWIG_IsOK(ecode2)) {
13712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13713 }
13714 arg2 = static_cast< int >(val2);
13715 ecode3 = SWIG_AsVal_int(obj2, &val3);
13716 if (!SWIG_IsOK(ecode3)) {
13717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13718 }
13719 arg3 = static_cast< int >(val3);
13720 {
13721 PyThreadState* __tstate = wxPyBeginAllowThreads();
13722 {
13723 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13724 result = (wxImage *) &_result_ref;
13725 }
13726 wxPyEndAllowThreads(__tstate);
13727 if (PyErr_Occurred()) SWIG_fail;
13728 }
13729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13730 return resultobj;
13731 fail:
13732 return NULL;
13733 }
13734
13735
13736 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13737 PyObject *resultobj = 0;
13738 wxImage *arg1 = (wxImage *) 0 ;
13739 wxSize *arg2 = 0 ;
13740 wxPoint *arg3 = 0 ;
13741 int arg4 = (int) -1 ;
13742 int arg5 = (int) -1 ;
13743 int arg6 = (int) -1 ;
13744 wxImage *result = 0 ;
13745 void *argp1 = 0 ;
13746 int res1 = 0 ;
13747 wxSize temp2 ;
13748 wxPoint temp3 ;
13749 int val4 ;
13750 int ecode4 = 0 ;
13751 int val5 ;
13752 int ecode5 = 0 ;
13753 int val6 ;
13754 int ecode6 = 0 ;
13755 PyObject * obj0 = 0 ;
13756 PyObject * obj1 = 0 ;
13757 PyObject * obj2 = 0 ;
13758 PyObject * obj3 = 0 ;
13759 PyObject * obj4 = 0 ;
13760 PyObject * obj5 = 0 ;
13761 char * kwnames[] = {
13762 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13763 };
13764
13765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13767 if (!SWIG_IsOK(res1)) {
13768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13769 }
13770 arg1 = reinterpret_cast< wxImage * >(argp1);
13771 {
13772 arg2 = &temp2;
13773 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13774 }
13775 {
13776 arg3 = &temp3;
13777 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13778 }
13779 if (obj3) {
13780 ecode4 = SWIG_AsVal_int(obj3, &val4);
13781 if (!SWIG_IsOK(ecode4)) {
13782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13783 }
13784 arg4 = static_cast< int >(val4);
13785 }
13786 if (obj4) {
13787 ecode5 = SWIG_AsVal_int(obj4, &val5);
13788 if (!SWIG_IsOK(ecode5)) {
13789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13790 }
13791 arg5 = static_cast< int >(val5);
13792 }
13793 if (obj5) {
13794 ecode6 = SWIG_AsVal_int(obj5, &val6);
13795 if (!SWIG_IsOK(ecode6)) {
13796 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13797 }
13798 arg6 = static_cast< int >(val6);
13799 }
13800 {
13801 PyThreadState* __tstate = wxPyBeginAllowThreads();
13802 {
13803 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13804 result = (wxImage *) &_result_ref;
13805 }
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13810 return resultobj;
13811 fail:
13812 return NULL;
13813 }
13814
13815
13816 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13817 PyObject *resultobj = 0;
13818 wxImage *arg1 = (wxImage *) 0 ;
13819 int arg2 ;
13820 int arg3 ;
13821 byte arg4 ;
13822 byte arg5 ;
13823 byte arg6 ;
13824 void *argp1 = 0 ;
13825 int res1 = 0 ;
13826 int val2 ;
13827 int ecode2 = 0 ;
13828 int val3 ;
13829 int ecode3 = 0 ;
13830 unsigned char val4 ;
13831 int ecode4 = 0 ;
13832 unsigned char val5 ;
13833 int ecode5 = 0 ;
13834 unsigned char val6 ;
13835 int ecode6 = 0 ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 PyObject * obj3 = 0 ;
13840 PyObject * obj4 = 0 ;
13841 PyObject * obj5 = 0 ;
13842 char * kwnames[] = {
13843 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13844 };
13845
13846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13848 if (!SWIG_IsOK(res1)) {
13849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13850 }
13851 arg1 = reinterpret_cast< wxImage * >(argp1);
13852 ecode2 = SWIG_AsVal_int(obj1, &val2);
13853 if (!SWIG_IsOK(ecode2)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13855 }
13856 arg2 = static_cast< int >(val2);
13857 ecode3 = SWIG_AsVal_int(obj2, &val3);
13858 if (!SWIG_IsOK(ecode3)) {
13859 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13860 }
13861 arg3 = static_cast< int >(val3);
13862 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13863 if (!SWIG_IsOK(ecode4)) {
13864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13865 }
13866 arg4 = static_cast< byte >(val4);
13867 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13868 if (!SWIG_IsOK(ecode5)) {
13869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13870 }
13871 arg5 = static_cast< byte >(val5);
13872 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13873 if (!SWIG_IsOK(ecode6)) {
13874 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13875 }
13876 arg6 = static_cast< byte >(val6);
13877 {
13878 PyThreadState* __tstate = wxPyBeginAllowThreads();
13879 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13880 wxPyEndAllowThreads(__tstate);
13881 if (PyErr_Occurred()) SWIG_fail;
13882 }
13883 resultobj = SWIG_Py_Void();
13884 return resultobj;
13885 fail:
13886 return NULL;
13887 }
13888
13889
13890 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxImage *arg1 = (wxImage *) 0 ;
13893 wxRect *arg2 = 0 ;
13894 byte arg3 ;
13895 byte arg4 ;
13896 byte arg5 ;
13897 void *argp1 = 0 ;
13898 int res1 = 0 ;
13899 wxRect temp2 ;
13900 unsigned char val3 ;
13901 int ecode3 = 0 ;
13902 unsigned char val4 ;
13903 int ecode4 = 0 ;
13904 unsigned char val5 ;
13905 int ecode5 = 0 ;
13906 PyObject * obj0 = 0 ;
13907 PyObject * obj1 = 0 ;
13908 PyObject * obj2 = 0 ;
13909 PyObject * obj3 = 0 ;
13910 PyObject * obj4 = 0 ;
13911 char * kwnames[] = {
13912 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13913 };
13914
13915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13917 if (!SWIG_IsOK(res1)) {
13918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13919 }
13920 arg1 = reinterpret_cast< wxImage * >(argp1);
13921 {
13922 arg2 = &temp2;
13923 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13924 }
13925 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13926 if (!SWIG_IsOK(ecode3)) {
13927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13928 }
13929 arg3 = static_cast< byte >(val3);
13930 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13931 if (!SWIG_IsOK(ecode4)) {
13932 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13933 }
13934 arg4 = static_cast< byte >(val4);
13935 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13936 if (!SWIG_IsOK(ecode5)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13938 }
13939 arg5 = static_cast< byte >(val5);
13940 {
13941 PyThreadState* __tstate = wxPyBeginAllowThreads();
13942 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13943 wxPyEndAllowThreads(__tstate);
13944 if (PyErr_Occurred()) SWIG_fail;
13945 }
13946 resultobj = SWIG_Py_Void();
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj = 0;
13955 wxImage *arg1 = (wxImage *) 0 ;
13956 int arg2 ;
13957 int arg3 ;
13958 byte result;
13959 void *argp1 = 0 ;
13960 int res1 = 0 ;
13961 int val2 ;
13962 int ecode2 = 0 ;
13963 int val3 ;
13964 int ecode3 = 0 ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 char * kwnames[] = {
13969 (char *) "self",(char *) "x",(char *) "y", NULL
13970 };
13971
13972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13974 if (!SWIG_IsOK(res1)) {
13975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13976 }
13977 arg1 = reinterpret_cast< wxImage * >(argp1);
13978 ecode2 = SWIG_AsVal_int(obj1, &val2);
13979 if (!SWIG_IsOK(ecode2)) {
13980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13981 }
13982 arg2 = static_cast< int >(val2);
13983 ecode3 = SWIG_AsVal_int(obj2, &val3);
13984 if (!SWIG_IsOK(ecode3)) {
13985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13986 }
13987 arg3 = static_cast< int >(val3);
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 result = (byte)(arg1)->GetRed(arg2,arg3);
13991 wxPyEndAllowThreads(__tstate);
13992 if (PyErr_Occurred()) SWIG_fail;
13993 }
13994 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13995 return resultobj;
13996 fail:
13997 return NULL;
13998 }
13999
14000
14001 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj = 0;
14003 wxImage *arg1 = (wxImage *) 0 ;
14004 int arg2 ;
14005 int arg3 ;
14006 byte result;
14007 void *argp1 = 0 ;
14008 int res1 = 0 ;
14009 int val2 ;
14010 int ecode2 = 0 ;
14011 int val3 ;
14012 int ecode3 = 0 ;
14013 PyObject * obj0 = 0 ;
14014 PyObject * obj1 = 0 ;
14015 PyObject * obj2 = 0 ;
14016 char * kwnames[] = {
14017 (char *) "self",(char *) "x",(char *) "y", NULL
14018 };
14019
14020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14022 if (!SWIG_IsOK(res1)) {
14023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14024 }
14025 arg1 = reinterpret_cast< wxImage * >(argp1);
14026 ecode2 = SWIG_AsVal_int(obj1, &val2);
14027 if (!SWIG_IsOK(ecode2)) {
14028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14029 }
14030 arg2 = static_cast< int >(val2);
14031 ecode3 = SWIG_AsVal_int(obj2, &val3);
14032 if (!SWIG_IsOK(ecode3)) {
14033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14034 }
14035 arg3 = static_cast< int >(val3);
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 result = (byte)(arg1)->GetGreen(arg2,arg3);
14039 wxPyEndAllowThreads(__tstate);
14040 if (PyErr_Occurred()) SWIG_fail;
14041 }
14042 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14043 return resultobj;
14044 fail:
14045 return NULL;
14046 }
14047
14048
14049 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14050 PyObject *resultobj = 0;
14051 wxImage *arg1 = (wxImage *) 0 ;
14052 int arg2 ;
14053 int arg3 ;
14054 byte result;
14055 void *argp1 = 0 ;
14056 int res1 = 0 ;
14057 int val2 ;
14058 int ecode2 = 0 ;
14059 int val3 ;
14060 int ecode3 = 0 ;
14061 PyObject * obj0 = 0 ;
14062 PyObject * obj1 = 0 ;
14063 PyObject * obj2 = 0 ;
14064 char * kwnames[] = {
14065 (char *) "self",(char *) "x",(char *) "y", NULL
14066 };
14067
14068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14070 if (!SWIG_IsOK(res1)) {
14071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14072 }
14073 arg1 = reinterpret_cast< wxImage * >(argp1);
14074 ecode2 = SWIG_AsVal_int(obj1, &val2);
14075 if (!SWIG_IsOK(ecode2)) {
14076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14077 }
14078 arg2 = static_cast< int >(val2);
14079 ecode3 = SWIG_AsVal_int(obj2, &val3);
14080 if (!SWIG_IsOK(ecode3)) {
14081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14082 }
14083 arg3 = static_cast< int >(val3);
14084 {
14085 PyThreadState* __tstate = wxPyBeginAllowThreads();
14086 result = (byte)(arg1)->GetBlue(arg2,arg3);
14087 wxPyEndAllowThreads(__tstate);
14088 if (PyErr_Occurred()) SWIG_fail;
14089 }
14090 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14091 return resultobj;
14092 fail:
14093 return NULL;
14094 }
14095
14096
14097 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14098 PyObject *resultobj = 0;
14099 wxImage *arg1 = (wxImage *) 0 ;
14100 int arg2 ;
14101 int arg3 ;
14102 byte arg4 ;
14103 void *argp1 = 0 ;
14104 int res1 = 0 ;
14105 int val2 ;
14106 int ecode2 = 0 ;
14107 int val3 ;
14108 int ecode3 = 0 ;
14109 unsigned char val4 ;
14110 int ecode4 = 0 ;
14111 PyObject * obj0 = 0 ;
14112 PyObject * obj1 = 0 ;
14113 PyObject * obj2 = 0 ;
14114 PyObject * obj3 = 0 ;
14115 char * kwnames[] = {
14116 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14117 };
14118
14119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14121 if (!SWIG_IsOK(res1)) {
14122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14123 }
14124 arg1 = reinterpret_cast< wxImage * >(argp1);
14125 ecode2 = SWIG_AsVal_int(obj1, &val2);
14126 if (!SWIG_IsOK(ecode2)) {
14127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14128 }
14129 arg2 = static_cast< int >(val2);
14130 ecode3 = SWIG_AsVal_int(obj2, &val3);
14131 if (!SWIG_IsOK(ecode3)) {
14132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14133 }
14134 arg3 = static_cast< int >(val3);
14135 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14136 if (!SWIG_IsOK(ecode4)) {
14137 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14138 }
14139 arg4 = static_cast< byte >(val4);
14140 {
14141 PyThreadState* __tstate = wxPyBeginAllowThreads();
14142 (arg1)->SetAlpha(arg2,arg3,arg4);
14143 wxPyEndAllowThreads(__tstate);
14144 if (PyErr_Occurred()) SWIG_fail;
14145 }
14146 resultobj = SWIG_Py_Void();
14147 return resultobj;
14148 fail:
14149 return NULL;
14150 }
14151
14152
14153 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14154 PyObject *resultobj = 0;
14155 wxImage *arg1 = (wxImage *) 0 ;
14156 int arg2 ;
14157 int arg3 ;
14158 byte result;
14159 void *argp1 = 0 ;
14160 int res1 = 0 ;
14161 int val2 ;
14162 int ecode2 = 0 ;
14163 int val3 ;
14164 int ecode3 = 0 ;
14165 PyObject * obj0 = 0 ;
14166 PyObject * obj1 = 0 ;
14167 PyObject * obj2 = 0 ;
14168 char * kwnames[] = {
14169 (char *) "self",(char *) "x",(char *) "y", NULL
14170 };
14171
14172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14174 if (!SWIG_IsOK(res1)) {
14175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14176 }
14177 arg1 = reinterpret_cast< wxImage * >(argp1);
14178 ecode2 = SWIG_AsVal_int(obj1, &val2);
14179 if (!SWIG_IsOK(ecode2)) {
14180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14181 }
14182 arg2 = static_cast< int >(val2);
14183 ecode3 = SWIG_AsVal_int(obj2, &val3);
14184 if (!SWIG_IsOK(ecode3)) {
14185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14186 }
14187 arg3 = static_cast< int >(val3);
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14195 return resultobj;
14196 fail:
14197 return NULL;
14198 }
14199
14200
14201 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14202 PyObject *resultobj = 0;
14203 wxImage *arg1 = (wxImage *) 0 ;
14204 bool result;
14205 void *argp1 = 0 ;
14206 int res1 = 0 ;
14207 PyObject *swig_obj[1] ;
14208
14209 if (!args) SWIG_fail;
14210 swig_obj[0] = args;
14211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14212 if (!SWIG_IsOK(res1)) {
14213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14214 }
14215 arg1 = reinterpret_cast< wxImage * >(argp1);
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 result = (bool)(arg1)->HasAlpha();
14219 wxPyEndAllowThreads(__tstate);
14220 if (PyErr_Occurred()) SWIG_fail;
14221 }
14222 {
14223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 PyObject *resultobj = 0;
14233 wxImage *arg1 = (wxImage *) 0 ;
14234 void *argp1 = 0 ;
14235 int res1 = 0 ;
14236 PyObject *swig_obj[1] ;
14237
14238 if (!args) SWIG_fail;
14239 swig_obj[0] = args;
14240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14241 if (!SWIG_IsOK(res1)) {
14242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14243 }
14244 arg1 = reinterpret_cast< wxImage * >(argp1);
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 (arg1)->InitAlpha();
14248 wxPyEndAllowThreads(__tstate);
14249 if (PyErr_Occurred()) SWIG_fail;
14250 }
14251 resultobj = SWIG_Py_Void();
14252 return resultobj;
14253 fail:
14254 return NULL;
14255 }
14256
14257
14258 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14259 PyObject *resultobj = 0;
14260 wxImage *arg1 = (wxImage *) 0 ;
14261 int arg2 ;
14262 int arg3 ;
14263 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 int val2 ;
14268 int ecode2 = 0 ;
14269 int val3 ;
14270 int ecode3 = 0 ;
14271 unsigned char val4 ;
14272 int ecode4 = 0 ;
14273 PyObject * obj0 = 0 ;
14274 PyObject * obj1 = 0 ;
14275 PyObject * obj2 = 0 ;
14276 PyObject * obj3 = 0 ;
14277 char * kwnames[] = {
14278 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14279 };
14280
14281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14285 }
14286 arg1 = reinterpret_cast< wxImage * >(argp1);
14287 ecode2 = SWIG_AsVal_int(obj1, &val2);
14288 if (!SWIG_IsOK(ecode2)) {
14289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14290 }
14291 arg2 = static_cast< int >(val2);
14292 ecode3 = SWIG_AsVal_int(obj2, &val3);
14293 if (!SWIG_IsOK(ecode3)) {
14294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14295 }
14296 arg3 = static_cast< int >(val3);
14297 if (obj3) {
14298 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14299 if (!SWIG_IsOK(ecode4)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14301 }
14302 arg4 = static_cast< byte >(val4);
14303 }
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14312 }
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxImage *arg1 = (wxImage *) 0 ;
14322 byte *arg2 = (byte *) 0 ;
14323 byte *arg3 = (byte *) 0 ;
14324 byte *arg4 = (byte *) 0 ;
14325 byte arg5 = (byte) 0 ;
14326 byte arg6 = (byte) 0 ;
14327 byte arg7 = (byte) 0 ;
14328 bool result;
14329 void *argp1 = 0 ;
14330 int res1 = 0 ;
14331 byte temp2 ;
14332 int res2 = SWIG_TMPOBJ ;
14333 byte temp3 ;
14334 int res3 = SWIG_TMPOBJ ;
14335 byte temp4 ;
14336 int res4 = SWIG_TMPOBJ ;
14337 unsigned char val5 ;
14338 int ecode5 = 0 ;
14339 unsigned char val6 ;
14340 int ecode6 = 0 ;
14341 unsigned char val7 ;
14342 int ecode7 = 0 ;
14343 PyObject * obj0 = 0 ;
14344 PyObject * obj1 = 0 ;
14345 PyObject * obj2 = 0 ;
14346 PyObject * obj3 = 0 ;
14347 char * kwnames[] = {
14348 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14349 };
14350
14351 arg2 = &temp2;
14352 arg3 = &temp3;
14353 arg4 = &temp4;
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14356 if (!SWIG_IsOK(res1)) {
14357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14358 }
14359 arg1 = reinterpret_cast< wxImage * >(argp1);
14360 if (obj1) {
14361 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14362 if (!SWIG_IsOK(ecode5)) {
14363 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14364 }
14365 arg5 = static_cast< byte >(val5);
14366 }
14367 if (obj2) {
14368 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14369 if (!SWIG_IsOK(ecode6)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14371 }
14372 arg6 = static_cast< byte >(val6);
14373 }
14374 if (obj3) {
14375 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14376 if (!SWIG_IsOK(ecode7)) {
14377 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14378 }
14379 arg7 = static_cast< byte >(val7);
14380 }
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14384 wxPyEndAllowThreads(__tstate);
14385 if (PyErr_Occurred()) SWIG_fail;
14386 }
14387 {
14388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14389 }
14390 if (SWIG_IsTmpObj(res2)) {
14391 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14392 } else {
14393 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14394 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14395 }
14396 if (SWIG_IsTmpObj(res3)) {
14397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14398 } else {
14399 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14401 }
14402 if (SWIG_IsTmpObj(res4)) {
14403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14404 } else {
14405 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14407 }
14408 return resultobj;
14409 fail:
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = 0;
14416 wxImage *arg1 = (wxImage *) 0 ;
14417 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14418 bool result;
14419 void *argp1 = 0 ;
14420 int res1 = 0 ;
14421 unsigned char val2 ;
14422 int ecode2 = 0 ;
14423 PyObject * obj0 = 0 ;
14424 PyObject * obj1 = 0 ;
14425 char * kwnames[] = {
14426 (char *) "self",(char *) "threshold", NULL
14427 };
14428
14429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14431 if (!SWIG_IsOK(res1)) {
14432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14433 }
14434 arg1 = reinterpret_cast< wxImage * >(argp1);
14435 if (obj1) {
14436 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14437 if (!SWIG_IsOK(ecode2)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14439 }
14440 arg2 = static_cast< byte >(val2);
14441 }
14442 {
14443 PyThreadState* __tstate = wxPyBeginAllowThreads();
14444 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 {
14449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14450 }
14451 return resultobj;
14452 fail:
14453 return NULL;
14454 }
14455
14456
14457 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14458 PyObject *resultobj = 0;
14459 wxImage *arg1 = (wxImage *) 0 ;
14460 byte arg2 ;
14461 byte arg3 ;
14462 byte arg4 ;
14463 bool result;
14464 void *argp1 = 0 ;
14465 int res1 = 0 ;
14466 unsigned char val2 ;
14467 int ecode2 = 0 ;
14468 unsigned char val3 ;
14469 int ecode3 = 0 ;
14470 unsigned char val4 ;
14471 int ecode4 = 0 ;
14472 PyObject * obj0 = 0 ;
14473 PyObject * obj1 = 0 ;
14474 PyObject * obj2 = 0 ;
14475 PyObject * obj3 = 0 ;
14476 char * kwnames[] = {
14477 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14478 };
14479
14480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14482 if (!SWIG_IsOK(res1)) {
14483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14484 }
14485 arg1 = reinterpret_cast< wxImage * >(argp1);
14486 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14487 if (!SWIG_IsOK(ecode2)) {
14488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14489 }
14490 arg2 = static_cast< byte >(val2);
14491 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14492 if (!SWIG_IsOK(ecode3)) {
14493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14494 }
14495 arg3 = static_cast< byte >(val3);
14496 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14497 if (!SWIG_IsOK(ecode4)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14499 }
14500 arg4 = static_cast< byte >(val4);
14501 {
14502 PyThreadState* __tstate = wxPyBeginAllowThreads();
14503 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14504 wxPyEndAllowThreads(__tstate);
14505 if (PyErr_Occurred()) SWIG_fail;
14506 }
14507 {
14508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14509 }
14510 return resultobj;
14511 fail:
14512 return NULL;
14513 }
14514
14515
14516 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14517 PyObject *resultobj = 0;
14518 wxImage *arg1 = (wxImage *) 0 ;
14519 wxImage *arg2 = 0 ;
14520 byte arg3 ;
14521 byte arg4 ;
14522 byte arg5 ;
14523 bool result;
14524 void *argp1 = 0 ;
14525 int res1 = 0 ;
14526 void *argp2 = 0 ;
14527 int res2 = 0 ;
14528 unsigned char val3 ;
14529 int ecode3 = 0 ;
14530 unsigned char val4 ;
14531 int ecode4 = 0 ;
14532 unsigned char val5 ;
14533 int ecode5 = 0 ;
14534 PyObject * obj0 = 0 ;
14535 PyObject * obj1 = 0 ;
14536 PyObject * obj2 = 0 ;
14537 PyObject * obj3 = 0 ;
14538 PyObject * obj4 = 0 ;
14539 char * kwnames[] = {
14540 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14541 };
14542
14543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14545 if (!SWIG_IsOK(res1)) {
14546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14547 }
14548 arg1 = reinterpret_cast< wxImage * >(argp1);
14549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14550 if (!SWIG_IsOK(res2)) {
14551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14552 }
14553 if (!argp2) {
14554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14555 }
14556 arg2 = reinterpret_cast< wxImage * >(argp2);
14557 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14558 if (!SWIG_IsOK(ecode3)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14560 }
14561 arg3 = static_cast< byte >(val3);
14562 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14563 if (!SWIG_IsOK(ecode4)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14565 }
14566 arg4 = static_cast< byte >(val4);
14567 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14568 if (!SWIG_IsOK(ecode5)) {
14569 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14570 }
14571 arg5 = static_cast< byte >(val5);
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14575 wxPyEndAllowThreads(__tstate);
14576 if (PyErr_Occurred()) SWIG_fail;
14577 }
14578 {
14579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14580 }
14581 return resultobj;
14582 fail:
14583 return NULL;
14584 }
14585
14586
14587 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14588 PyObject *resultobj = 0;
14589 wxString *arg1 = 0 ;
14590 bool result;
14591 bool temp1 = false ;
14592 PyObject * obj0 = 0 ;
14593 char * kwnames[] = {
14594 (char *) "filename", NULL
14595 };
14596
14597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14598 {
14599 arg1 = wxString_in_helper(obj0);
14600 if (arg1 == NULL) SWIG_fail;
14601 temp1 = true;
14602 }
14603 {
14604 PyThreadState* __tstate = wxPyBeginAllowThreads();
14605 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14606 wxPyEndAllowThreads(__tstate);
14607 if (PyErr_Occurred()) SWIG_fail;
14608 }
14609 {
14610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14611 }
14612 {
14613 if (temp1)
14614 delete arg1;
14615 }
14616 return resultobj;
14617 fail:
14618 {
14619 if (temp1)
14620 delete arg1;
14621 }
14622 return NULL;
14623 }
14624
14625
14626 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj = 0;
14628 wxString *arg1 = 0 ;
14629 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14630 int result;
14631 bool temp1 = false ;
14632 long val2 ;
14633 int ecode2 = 0 ;
14634 PyObject * obj0 = 0 ;
14635 PyObject * obj1 = 0 ;
14636 char * kwnames[] = {
14637 (char *) "filename",(char *) "type", NULL
14638 };
14639
14640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14641 {
14642 arg1 = wxString_in_helper(obj0);
14643 if (arg1 == NULL) SWIG_fail;
14644 temp1 = true;
14645 }
14646 if (obj1) {
14647 ecode2 = SWIG_AsVal_long(obj1, &val2);
14648 if (!SWIG_IsOK(ecode2)) {
14649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14650 }
14651 arg2 = static_cast< long >(val2);
14652 }
14653 {
14654 PyThreadState* __tstate = wxPyBeginAllowThreads();
14655 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14656 wxPyEndAllowThreads(__tstate);
14657 if (PyErr_Occurred()) SWIG_fail;
14658 }
14659 resultobj = SWIG_From_int(static_cast< int >(result));
14660 {
14661 if (temp1)
14662 delete arg1;
14663 }
14664 return resultobj;
14665 fail:
14666 {
14667 if (temp1)
14668 delete arg1;
14669 }
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj = 0;
14676 wxImage *arg1 = (wxImage *) 0 ;
14677 wxString *arg2 = 0 ;
14678 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14679 int arg4 = (int) -1 ;
14680 bool result;
14681 void *argp1 = 0 ;
14682 int res1 = 0 ;
14683 bool temp2 = false ;
14684 long val3 ;
14685 int ecode3 = 0 ;
14686 int val4 ;
14687 int ecode4 = 0 ;
14688 PyObject * obj0 = 0 ;
14689 PyObject * obj1 = 0 ;
14690 PyObject * obj2 = 0 ;
14691 PyObject * obj3 = 0 ;
14692 char * kwnames[] = {
14693 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14694 };
14695
14696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14698 if (!SWIG_IsOK(res1)) {
14699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14700 }
14701 arg1 = reinterpret_cast< wxImage * >(argp1);
14702 {
14703 arg2 = wxString_in_helper(obj1);
14704 if (arg2 == NULL) SWIG_fail;
14705 temp2 = true;
14706 }
14707 if (obj2) {
14708 ecode3 = SWIG_AsVal_long(obj2, &val3);
14709 if (!SWIG_IsOK(ecode3)) {
14710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14711 }
14712 arg3 = static_cast< long >(val3);
14713 }
14714 if (obj3) {
14715 ecode4 = SWIG_AsVal_int(obj3, &val4);
14716 if (!SWIG_IsOK(ecode4)) {
14717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14718 }
14719 arg4 = static_cast< int >(val4);
14720 }
14721 {
14722 PyThreadState* __tstate = wxPyBeginAllowThreads();
14723 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 {
14728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14729 }
14730 {
14731 if (temp2)
14732 delete arg2;
14733 }
14734 return resultobj;
14735 fail:
14736 {
14737 if (temp2)
14738 delete arg2;
14739 }
14740 return NULL;
14741 }
14742
14743
14744 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14745 PyObject *resultobj = 0;
14746 wxImage *arg1 = (wxImage *) 0 ;
14747 wxString *arg2 = 0 ;
14748 wxString *arg3 = 0 ;
14749 int arg4 = (int) -1 ;
14750 bool result;
14751 void *argp1 = 0 ;
14752 int res1 = 0 ;
14753 bool temp2 = false ;
14754 bool temp3 = false ;
14755 int val4 ;
14756 int ecode4 = 0 ;
14757 PyObject * obj0 = 0 ;
14758 PyObject * obj1 = 0 ;
14759 PyObject * obj2 = 0 ;
14760 PyObject * obj3 = 0 ;
14761 char * kwnames[] = {
14762 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14763 };
14764
14765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14767 if (!SWIG_IsOK(res1)) {
14768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14769 }
14770 arg1 = reinterpret_cast< wxImage * >(argp1);
14771 {
14772 arg2 = wxString_in_helper(obj1);
14773 if (arg2 == NULL) SWIG_fail;
14774 temp2 = true;
14775 }
14776 {
14777 arg3 = wxString_in_helper(obj2);
14778 if (arg3 == NULL) SWIG_fail;
14779 temp3 = true;
14780 }
14781 if (obj3) {
14782 ecode4 = SWIG_AsVal_int(obj3, &val4);
14783 if (!SWIG_IsOK(ecode4)) {
14784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14785 }
14786 arg4 = static_cast< int >(val4);
14787 }
14788 {
14789 PyThreadState* __tstate = wxPyBeginAllowThreads();
14790 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14791 wxPyEndAllowThreads(__tstate);
14792 if (PyErr_Occurred()) SWIG_fail;
14793 }
14794 {
14795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14796 }
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 {
14802 if (temp3)
14803 delete arg3;
14804 }
14805 return resultobj;
14806 fail:
14807 {
14808 if (temp2)
14809 delete arg2;
14810 }
14811 {
14812 if (temp3)
14813 delete arg3;
14814 }
14815 return NULL;
14816 }
14817
14818
14819 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14820 PyObject *resultobj = 0;
14821 wxImage *arg1 = (wxImage *) 0 ;
14822 wxString *arg2 = 0 ;
14823 int arg3 ;
14824 bool result;
14825 void *argp1 = 0 ;
14826 int res1 = 0 ;
14827 bool temp2 = false ;
14828 int val3 ;
14829 int ecode3 = 0 ;
14830 PyObject * obj0 = 0 ;
14831 PyObject * obj1 = 0 ;
14832 PyObject * obj2 = 0 ;
14833 char * kwnames[] = {
14834 (char *) "self",(char *) "name",(char *) "type", NULL
14835 };
14836
14837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14839 if (!SWIG_IsOK(res1)) {
14840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14841 }
14842 arg1 = reinterpret_cast< wxImage * >(argp1);
14843 {
14844 arg2 = wxString_in_helper(obj1);
14845 if (arg2 == NULL) SWIG_fail;
14846 temp2 = true;
14847 }
14848 ecode3 = SWIG_AsVal_int(obj2, &val3);
14849 if (!SWIG_IsOK(ecode3)) {
14850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14851 }
14852 arg3 = static_cast< int >(val3);
14853 {
14854 PyThreadState* __tstate = wxPyBeginAllowThreads();
14855 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
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 (temp2)
14864 delete arg2;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (temp2)
14870 delete arg2;
14871 }
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxImage *arg1 = (wxImage *) 0 ;
14879 wxString *arg2 = 0 ;
14880 wxString *arg3 = 0 ;
14881 bool result;
14882 void *argp1 = 0 ;
14883 int res1 = 0 ;
14884 bool temp2 = false ;
14885 bool temp3 = false ;
14886 PyObject * obj0 = 0 ;
14887 PyObject * obj1 = 0 ;
14888 PyObject * obj2 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImage * >(argp1);
14899 {
14900 arg2 = wxString_in_helper(obj1);
14901 if (arg2 == NULL) SWIG_fail;
14902 temp2 = true;
14903 }
14904 {
14905 arg3 = wxString_in_helper(obj2);
14906 if (arg3 == NULL) SWIG_fail;
14907 temp3 = true;
14908 }
14909 {
14910 PyThreadState* __tstate = wxPyBeginAllowThreads();
14911 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14912 wxPyEndAllowThreads(__tstate);
14913 if (PyErr_Occurred()) SWIG_fail;
14914 }
14915 {
14916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14917 }
14918 {
14919 if (temp2)
14920 delete arg2;
14921 }
14922 {
14923 if (temp3)
14924 delete arg3;
14925 }
14926 return resultobj;
14927 fail:
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 {
14933 if (temp3)
14934 delete arg3;
14935 }
14936 return NULL;
14937 }
14938
14939
14940 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14941 PyObject *resultobj = 0;
14942 wxInputStream *arg1 = 0 ;
14943 bool result;
14944 wxPyInputStream *temp1 ;
14945 bool created1 ;
14946 PyObject * obj0 = 0 ;
14947 char * kwnames[] = {
14948 (char *) "stream", NULL
14949 };
14950
14951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14952 {
14953 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14954 arg1 = temp1->m_wxis;
14955 created1 = false;
14956 } else {
14957 PyErr_Clear(); // clear the failure of the wxPyConvert above
14958 arg1 = wxPyCBInputStream_create(obj0, false);
14959 if (arg1 == NULL) {
14960 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14961 SWIG_fail;
14962 }
14963 created1 = true;
14964 }
14965 }
14966 {
14967 PyThreadState* __tstate = wxPyBeginAllowThreads();
14968 result = (bool)wxImage::CanRead(*arg1);
14969 wxPyEndAllowThreads(__tstate);
14970 if (PyErr_Occurred()) SWIG_fail;
14971 }
14972 {
14973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14974 }
14975 {
14976 if (created1) delete arg1;
14977 }
14978 return resultobj;
14979 fail:
14980 {
14981 if (created1) delete arg1;
14982 }
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj = 0;
14989 wxImage *arg1 = (wxImage *) 0 ;
14990 wxInputStream *arg2 = 0 ;
14991 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14992 int arg4 = (int) -1 ;
14993 bool result;
14994 void *argp1 = 0 ;
14995 int res1 = 0 ;
14996 wxPyInputStream *temp2 ;
14997 bool created2 ;
14998 long val3 ;
14999 int ecode3 = 0 ;
15000 int val4 ;
15001 int ecode4 = 0 ;
15002 PyObject * obj0 = 0 ;
15003 PyObject * obj1 = 0 ;
15004 PyObject * obj2 = 0 ;
15005 PyObject * obj3 = 0 ;
15006 char * kwnames[] = {
15007 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15008 };
15009
15010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15014 }
15015 arg1 = reinterpret_cast< wxImage * >(argp1);
15016 {
15017 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15018 arg2 = temp2->m_wxis;
15019 created2 = false;
15020 } else {
15021 PyErr_Clear(); // clear the failure of the wxPyConvert above
15022 arg2 = wxPyCBInputStream_create(obj1, false);
15023 if (arg2 == NULL) {
15024 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15025 SWIG_fail;
15026 }
15027 created2 = true;
15028 }
15029 }
15030 if (obj2) {
15031 ecode3 = SWIG_AsVal_long(obj2, &val3);
15032 if (!SWIG_IsOK(ecode3)) {
15033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15034 }
15035 arg3 = static_cast< long >(val3);
15036 }
15037 if (obj3) {
15038 ecode4 = SWIG_AsVal_int(obj3, &val4);
15039 if (!SWIG_IsOK(ecode4)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15041 }
15042 arg4 = static_cast< int >(val4);
15043 }
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 {
15051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15052 }
15053 {
15054 if (created2) delete arg2;
15055 }
15056 return resultobj;
15057 fail:
15058 {
15059 if (created2) delete arg2;
15060 }
15061 return NULL;
15062 }
15063
15064
15065 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = 0;
15067 wxImage *arg1 = (wxImage *) 0 ;
15068 wxInputStream *arg2 = 0 ;
15069 wxString *arg3 = 0 ;
15070 int arg4 = (int) -1 ;
15071 bool result;
15072 void *argp1 = 0 ;
15073 int res1 = 0 ;
15074 wxPyInputStream *temp2 ;
15075 bool created2 ;
15076 bool temp3 = false ;
15077 int val4 ;
15078 int ecode4 = 0 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 PyObject * obj2 = 0 ;
15082 PyObject * obj3 = 0 ;
15083 char * kwnames[] = {
15084 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15085 };
15086
15087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15089 if (!SWIG_IsOK(res1)) {
15090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15091 }
15092 arg1 = reinterpret_cast< wxImage * >(argp1);
15093 {
15094 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15095 arg2 = temp2->m_wxis;
15096 created2 = false;
15097 } else {
15098 PyErr_Clear(); // clear the failure of the wxPyConvert above
15099 arg2 = wxPyCBInputStream_create(obj1, false);
15100 if (arg2 == NULL) {
15101 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15102 SWIG_fail;
15103 }
15104 created2 = true;
15105 }
15106 }
15107 {
15108 arg3 = wxString_in_helper(obj2);
15109 if (arg3 == NULL) SWIG_fail;
15110 temp3 = true;
15111 }
15112 if (obj3) {
15113 ecode4 = SWIG_AsVal_int(obj3, &val4);
15114 if (!SWIG_IsOK(ecode4)) {
15115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15116 }
15117 arg4 = static_cast< int >(val4);
15118 }
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 {
15126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15127 }
15128 {
15129 if (created2) delete arg2;
15130 }
15131 {
15132 if (temp3)
15133 delete arg3;
15134 }
15135 return resultobj;
15136 fail:
15137 {
15138 if (created2) delete arg2;
15139 }
15140 {
15141 if (temp3)
15142 delete arg3;
15143 }
15144 return NULL;
15145 }
15146
15147
15148 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15149 PyObject *resultobj = 0;
15150 wxImage *arg1 = (wxImage *) 0 ;
15151 bool result;
15152 void *argp1 = 0 ;
15153 int res1 = 0 ;
15154 PyObject *swig_obj[1] ;
15155
15156 if (!args) SWIG_fail;
15157 swig_obj[0] = args;
15158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage * >(argp1);
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 result = (bool)(arg1)->Ok();
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 {
15170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15171 }
15172 return resultobj;
15173 fail:
15174 return NULL;
15175 }
15176
15177
15178 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15179 PyObject *resultobj = 0;
15180 wxImage *arg1 = (wxImage *) 0 ;
15181 int result;
15182 void *argp1 = 0 ;
15183 int res1 = 0 ;
15184 PyObject *swig_obj[1] ;
15185
15186 if (!args) SWIG_fail;
15187 swig_obj[0] = args;
15188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15189 if (!SWIG_IsOK(res1)) {
15190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15191 }
15192 arg1 = reinterpret_cast< wxImage * >(argp1);
15193 {
15194 PyThreadState* __tstate = wxPyBeginAllowThreads();
15195 result = (int)(arg1)->GetWidth();
15196 wxPyEndAllowThreads(__tstate);
15197 if (PyErr_Occurred()) SWIG_fail;
15198 }
15199 resultobj = SWIG_From_int(static_cast< int >(result));
15200 return resultobj;
15201 fail:
15202 return NULL;
15203 }
15204
15205
15206 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15207 PyObject *resultobj = 0;
15208 wxImage *arg1 = (wxImage *) 0 ;
15209 int result;
15210 void *argp1 = 0 ;
15211 int res1 = 0 ;
15212 PyObject *swig_obj[1] ;
15213
15214 if (!args) SWIG_fail;
15215 swig_obj[0] = args;
15216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15217 if (!SWIG_IsOK(res1)) {
15218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15219 }
15220 arg1 = reinterpret_cast< wxImage * >(argp1);
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 result = (int)(arg1)->GetHeight();
15224 wxPyEndAllowThreads(__tstate);
15225 if (PyErr_Occurred()) SWIG_fail;
15226 }
15227 resultobj = SWIG_From_int(static_cast< int >(result));
15228 return resultobj;
15229 fail:
15230 return NULL;
15231 }
15232
15233
15234 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15235 PyObject *resultobj = 0;
15236 wxImage *arg1 = (wxImage *) 0 ;
15237 wxSize result;
15238 void *argp1 = 0 ;
15239 int res1 = 0 ;
15240 PyObject *swig_obj[1] ;
15241
15242 if (!args) SWIG_fail;
15243 swig_obj[0] = args;
15244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15245 if (!SWIG_IsOK(res1)) {
15246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15247 }
15248 arg1 = reinterpret_cast< wxImage * >(argp1);
15249 {
15250 PyThreadState* __tstate = wxPyBeginAllowThreads();
15251 result = wxImage_GetSize(arg1);
15252 wxPyEndAllowThreads(__tstate);
15253 if (PyErr_Occurred()) SWIG_fail;
15254 }
15255 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15256 return resultobj;
15257 fail:
15258 return NULL;
15259 }
15260
15261
15262 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15263 PyObject *resultobj = 0;
15264 wxImage *arg1 = (wxImage *) 0 ;
15265 wxRect *arg2 = 0 ;
15266 SwigValueWrapper<wxImage > result;
15267 void *argp1 = 0 ;
15268 int res1 = 0 ;
15269 wxRect temp2 ;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 char * kwnames[] = {
15273 (char *) "self",(char *) "rect", NULL
15274 };
15275
15276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15278 if (!SWIG_IsOK(res1)) {
15279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15280 }
15281 arg1 = reinterpret_cast< wxImage * >(argp1);
15282 {
15283 arg2 = &temp2;
15284 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15285 }
15286 {
15287 PyThreadState* __tstate = wxPyBeginAllowThreads();
15288 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15289 wxPyEndAllowThreads(__tstate);
15290 if (PyErr_Occurred()) SWIG_fail;
15291 }
15292 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15293 return resultobj;
15294 fail:
15295 return NULL;
15296 }
15297
15298
15299 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15300 PyObject *resultobj = 0;
15301 wxImage *arg1 = (wxImage *) 0 ;
15302 wxSize *arg2 = 0 ;
15303 wxPoint *arg3 = 0 ;
15304 int arg4 = (int) -1 ;
15305 int arg5 = (int) -1 ;
15306 int arg6 = (int) -1 ;
15307 SwigValueWrapper<wxImage > result;
15308 void *argp1 = 0 ;
15309 int res1 = 0 ;
15310 wxSize temp2 ;
15311 wxPoint temp3 ;
15312 int val4 ;
15313 int ecode4 = 0 ;
15314 int val5 ;
15315 int ecode5 = 0 ;
15316 int val6 ;
15317 int ecode6 = 0 ;
15318 PyObject * obj0 = 0 ;
15319 PyObject * obj1 = 0 ;
15320 PyObject * obj2 = 0 ;
15321 PyObject * obj3 = 0 ;
15322 PyObject * obj4 = 0 ;
15323 PyObject * obj5 = 0 ;
15324 char * kwnames[] = {
15325 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15326 };
15327
15328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15332 }
15333 arg1 = reinterpret_cast< wxImage * >(argp1);
15334 {
15335 arg2 = &temp2;
15336 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15337 }
15338 {
15339 arg3 = &temp3;
15340 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15341 }
15342 if (obj3) {
15343 ecode4 = SWIG_AsVal_int(obj3, &val4);
15344 if (!SWIG_IsOK(ecode4)) {
15345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15346 }
15347 arg4 = static_cast< int >(val4);
15348 }
15349 if (obj4) {
15350 ecode5 = SWIG_AsVal_int(obj4, &val5);
15351 if (!SWIG_IsOK(ecode5)) {
15352 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15353 }
15354 arg5 = static_cast< int >(val5);
15355 }
15356 if (obj5) {
15357 ecode6 = SWIG_AsVal_int(obj5, &val6);
15358 if (!SWIG_IsOK(ecode6)) {
15359 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15360 }
15361 arg6 = static_cast< int >(val6);
15362 }
15363 {
15364 PyThreadState* __tstate = wxPyBeginAllowThreads();
15365 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15366 wxPyEndAllowThreads(__tstate);
15367 if (PyErr_Occurred()) SWIG_fail;
15368 }
15369 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15370 return resultobj;
15371 fail:
15372 return NULL;
15373 }
15374
15375
15376 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15377 PyObject *resultobj = 0;
15378 wxImage *arg1 = (wxImage *) 0 ;
15379 SwigValueWrapper<wxImage > result;
15380 void *argp1 = 0 ;
15381 int res1 = 0 ;
15382 PyObject *swig_obj[1] ;
15383
15384 if (!args) SWIG_fail;
15385 swig_obj[0] = args;
15386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15387 if (!SWIG_IsOK(res1)) {
15388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15389 }
15390 arg1 = reinterpret_cast< wxImage * >(argp1);
15391 {
15392 PyThreadState* __tstate = wxPyBeginAllowThreads();
15393 result = (arg1)->Copy();
15394 wxPyEndAllowThreads(__tstate);
15395 if (PyErr_Occurred()) SWIG_fail;
15396 }
15397 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15405 PyObject *resultobj = 0;
15406 wxImage *arg1 = (wxImage *) 0 ;
15407 wxImage *arg2 = 0 ;
15408 int arg3 ;
15409 int arg4 ;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 void *argp2 = 0 ;
15413 int res2 = 0 ;
15414 int val3 ;
15415 int ecode3 = 0 ;
15416 int val4 ;
15417 int ecode4 = 0 ;
15418 PyObject * obj0 = 0 ;
15419 PyObject * obj1 = 0 ;
15420 PyObject * obj2 = 0 ;
15421 PyObject * obj3 = 0 ;
15422 char * kwnames[] = {
15423 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15424 };
15425
15426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15428 if (!SWIG_IsOK(res1)) {
15429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15430 }
15431 arg1 = reinterpret_cast< wxImage * >(argp1);
15432 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15433 if (!SWIG_IsOK(res2)) {
15434 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15435 }
15436 if (!argp2) {
15437 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15438 }
15439 arg2 = reinterpret_cast< wxImage * >(argp2);
15440 ecode3 = SWIG_AsVal_int(obj2, &val3);
15441 if (!SWIG_IsOK(ecode3)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15443 }
15444 arg3 = static_cast< int >(val3);
15445 ecode4 = SWIG_AsVal_int(obj3, &val4);
15446 if (!SWIG_IsOK(ecode4)) {
15447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15448 }
15449 arg4 = static_cast< int >(val4);
15450 {
15451 PyThreadState* __tstate = wxPyBeginAllowThreads();
15452 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15453 wxPyEndAllowThreads(__tstate);
15454 if (PyErr_Occurred()) SWIG_fail;
15455 }
15456 resultobj = SWIG_Py_Void();
15457 return resultobj;
15458 fail:
15459 return NULL;
15460 }
15461
15462
15463 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15464 PyObject *resultobj = 0;
15465 wxImage *arg1 = (wxImage *) 0 ;
15466 PyObject *result = 0 ;
15467 void *argp1 = 0 ;
15468 int res1 = 0 ;
15469 PyObject *swig_obj[1] ;
15470
15471 if (!args) SWIG_fail;
15472 swig_obj[0] = args;
15473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15474 if (!SWIG_IsOK(res1)) {
15475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15476 }
15477 arg1 = reinterpret_cast< wxImage * >(argp1);
15478 {
15479 PyThreadState* __tstate = wxPyBeginAllowThreads();
15480 result = (PyObject *)wxImage_GetData(arg1);
15481 wxPyEndAllowThreads(__tstate);
15482 if (PyErr_Occurred()) SWIG_fail;
15483 }
15484 resultobj = result;
15485 return resultobj;
15486 fail:
15487 return NULL;
15488 }
15489
15490
15491 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15492 PyObject *resultobj = 0;
15493 wxImage *arg1 = (wxImage *) 0 ;
15494 buffer arg2 ;
15495 int arg3 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 PyObject * obj0 = 0 ;
15499 PyObject * obj1 = 0 ;
15500 char * kwnames[] = {
15501 (char *) "self",(char *) "data", NULL
15502 };
15503
15504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15506 if (!SWIG_IsOK(res1)) {
15507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15508 }
15509 arg1 = reinterpret_cast< wxImage * >(argp1);
15510 {
15511 if (obj1 != Py_None) {
15512 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15513 }
15514 }
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 wxImage_SetData(arg1,arg2,arg3);
15518 wxPyEndAllowThreads(__tstate);
15519 if (PyErr_Occurred()) SWIG_fail;
15520 }
15521 resultobj = SWIG_Py_Void();
15522 return resultobj;
15523 fail:
15524 return NULL;
15525 }
15526
15527
15528 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15529 PyObject *resultobj = 0;
15530 wxImage *arg1 = (wxImage *) 0 ;
15531 PyObject *result = 0 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15541 }
15542 arg1 = reinterpret_cast< wxImage * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 resultobj = result;
15550 return resultobj;
15551 fail:
15552 return NULL;
15553 }
15554
15555
15556 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj = 0;
15558 wxImage *arg1 = (wxImage *) 0 ;
15559 buffer arg2 ;
15560 int arg3 ;
15561 void *argp1 = 0 ;
15562 int res1 = 0 ;
15563 PyObject * obj0 = 0 ;
15564 PyObject * obj1 = 0 ;
15565 char * kwnames[] = {
15566 (char *) "self",(char *) "data", NULL
15567 };
15568
15569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15571 if (!SWIG_IsOK(res1)) {
15572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15573 }
15574 arg1 = reinterpret_cast< wxImage * >(argp1);
15575 {
15576 if (obj1 != Py_None) {
15577 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15578 }
15579 }
15580 {
15581 PyThreadState* __tstate = wxPyBeginAllowThreads();
15582 wxImage_SetDataBuffer(arg1,arg2,arg3);
15583 wxPyEndAllowThreads(__tstate);
15584 if (PyErr_Occurred()) SWIG_fail;
15585 }
15586 resultobj = SWIG_Py_Void();
15587 return resultobj;
15588 fail:
15589 return NULL;
15590 }
15591
15592
15593 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15594 PyObject *resultobj = 0;
15595 wxImage *arg1 = (wxImage *) 0 ;
15596 PyObject *result = 0 ;
15597 void *argp1 = 0 ;
15598 int res1 = 0 ;
15599 PyObject *swig_obj[1] ;
15600
15601 if (!args) SWIG_fail;
15602 swig_obj[0] = args;
15603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15604 if (!SWIG_IsOK(res1)) {
15605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15606 }
15607 arg1 = reinterpret_cast< wxImage * >(argp1);
15608 {
15609 PyThreadState* __tstate = wxPyBeginAllowThreads();
15610 result = (PyObject *)wxImage_GetAlphaData(arg1);
15611 wxPyEndAllowThreads(__tstate);
15612 if (PyErr_Occurred()) SWIG_fail;
15613 }
15614 resultobj = result;
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj = 0;
15623 wxImage *arg1 = (wxImage *) 0 ;
15624 buffer arg2 ;
15625 int arg3 ;
15626 void *argp1 = 0 ;
15627 int res1 = 0 ;
15628 PyObject * obj0 = 0 ;
15629 PyObject * obj1 = 0 ;
15630 char * kwnames[] = {
15631 (char *) "self",(char *) "alpha", NULL
15632 };
15633
15634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15638 }
15639 arg1 = reinterpret_cast< wxImage * >(argp1);
15640 {
15641 if (obj1 != Py_None) {
15642 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15643 }
15644 }
15645 {
15646 PyThreadState* __tstate = wxPyBeginAllowThreads();
15647 wxImage_SetAlphaData(arg1,arg2,arg3);
15648 wxPyEndAllowThreads(__tstate);
15649 if (PyErr_Occurred()) SWIG_fail;
15650 }
15651 resultobj = SWIG_Py_Void();
15652 return resultobj;
15653 fail:
15654 return NULL;
15655 }
15656
15657
15658 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15659 PyObject *resultobj = 0;
15660 wxImage *arg1 = (wxImage *) 0 ;
15661 PyObject *result = 0 ;
15662 void *argp1 = 0 ;
15663 int res1 = 0 ;
15664 PyObject *swig_obj[1] ;
15665
15666 if (!args) SWIG_fail;
15667 swig_obj[0] = args;
15668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15669 if (!SWIG_IsOK(res1)) {
15670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15671 }
15672 arg1 = reinterpret_cast< wxImage * >(argp1);
15673 {
15674 PyThreadState* __tstate = wxPyBeginAllowThreads();
15675 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15676 wxPyEndAllowThreads(__tstate);
15677 if (PyErr_Occurred()) SWIG_fail;
15678 }
15679 resultobj = result;
15680 return resultobj;
15681 fail:
15682 return NULL;
15683 }
15684
15685
15686 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15687 PyObject *resultobj = 0;
15688 wxImage *arg1 = (wxImage *) 0 ;
15689 buffer arg2 ;
15690 int arg3 ;
15691 void *argp1 = 0 ;
15692 int res1 = 0 ;
15693 PyObject * obj0 = 0 ;
15694 PyObject * obj1 = 0 ;
15695 char * kwnames[] = {
15696 (char *) "self",(char *) "alpha", NULL
15697 };
15698
15699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15701 if (!SWIG_IsOK(res1)) {
15702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15703 }
15704 arg1 = reinterpret_cast< wxImage * >(argp1);
15705 {
15706 if (obj1 != Py_None) {
15707 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15708 }
15709 }
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 resultobj = SWIG_Py_Void();
15717 return resultobj;
15718 fail:
15719 return NULL;
15720 }
15721
15722
15723 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15724 PyObject *resultobj = 0;
15725 wxImage *arg1 = (wxImage *) 0 ;
15726 byte arg2 ;
15727 byte arg3 ;
15728 byte arg4 ;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 unsigned char val2 ;
15732 int ecode2 = 0 ;
15733 unsigned char val3 ;
15734 int ecode3 = 0 ;
15735 unsigned char val4 ;
15736 int ecode4 = 0 ;
15737 PyObject * obj0 = 0 ;
15738 PyObject * obj1 = 0 ;
15739 PyObject * obj2 = 0 ;
15740 PyObject * obj3 = 0 ;
15741 char * kwnames[] = {
15742 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15743 };
15744
15745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15747 if (!SWIG_IsOK(res1)) {
15748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15749 }
15750 arg1 = reinterpret_cast< wxImage * >(argp1);
15751 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15752 if (!SWIG_IsOK(ecode2)) {
15753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15754 }
15755 arg2 = static_cast< byte >(val2);
15756 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15757 if (!SWIG_IsOK(ecode3)) {
15758 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15759 }
15760 arg3 = static_cast< byte >(val3);
15761 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15762 if (!SWIG_IsOK(ecode4)) {
15763 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15764 }
15765 arg4 = static_cast< byte >(val4);
15766 {
15767 PyThreadState* __tstate = wxPyBeginAllowThreads();
15768 (arg1)->SetMaskColour(arg2,arg3,arg4);
15769 wxPyEndAllowThreads(__tstate);
15770 if (PyErr_Occurred()) SWIG_fail;
15771 }
15772 resultobj = SWIG_Py_Void();
15773 return resultobj;
15774 fail:
15775 return NULL;
15776 }
15777
15778
15779 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15780 PyObject *resultobj = 0;
15781 wxImage *arg1 = (wxImage *) 0 ;
15782 byte *arg2 = (byte *) 0 ;
15783 byte *arg3 = (byte *) 0 ;
15784 byte *arg4 = (byte *) 0 ;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 byte temp2 ;
15788 int res2 = SWIG_TMPOBJ ;
15789 byte temp3 ;
15790 int res3 = SWIG_TMPOBJ ;
15791 byte temp4 ;
15792 int res4 = SWIG_TMPOBJ ;
15793 PyObject *swig_obj[1] ;
15794
15795 arg2 = &temp2;
15796 arg3 = &temp3;
15797 arg4 = &temp4;
15798 if (!args) SWIG_fail;
15799 swig_obj[0] = args;
15800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15801 if (!SWIG_IsOK(res1)) {
15802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15803 }
15804 arg1 = reinterpret_cast< wxImage * >(argp1);
15805 {
15806 PyThreadState* __tstate = wxPyBeginAllowThreads();
15807 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 resultobj = SWIG_Py_Void();
15812 if (SWIG_IsTmpObj(res2)) {
15813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15814 } else {
15815 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15817 }
15818 if (SWIG_IsTmpObj(res3)) {
15819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15820 } else {
15821 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15823 }
15824 if (SWIG_IsTmpObj(res4)) {
15825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15826 } else {
15827 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15829 }
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxImage *arg1 = (wxImage *) 0 ;
15839 byte result;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15849 }
15850 arg1 = reinterpret_cast< wxImage * >(argp1);
15851 {
15852 PyThreadState* __tstate = wxPyBeginAllowThreads();
15853 result = (byte)(arg1)->GetMaskRed();
15854 wxPyEndAllowThreads(__tstate);
15855 if (PyErr_Occurred()) SWIG_fail;
15856 }
15857 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15858 return resultobj;
15859 fail:
15860 return NULL;
15861 }
15862
15863
15864 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15865 PyObject *resultobj = 0;
15866 wxImage *arg1 = (wxImage *) 0 ;
15867 byte result;
15868 void *argp1 = 0 ;
15869 int res1 = 0 ;
15870 PyObject *swig_obj[1] ;
15871
15872 if (!args) SWIG_fail;
15873 swig_obj[0] = args;
15874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15875 if (!SWIG_IsOK(res1)) {
15876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15877 }
15878 arg1 = reinterpret_cast< wxImage * >(argp1);
15879 {
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = (byte)(arg1)->GetMaskGreen();
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15886 return resultobj;
15887 fail:
15888 return NULL;
15889 }
15890
15891
15892 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15893 PyObject *resultobj = 0;
15894 wxImage *arg1 = (wxImage *) 0 ;
15895 byte result;
15896 void *argp1 = 0 ;
15897 int res1 = 0 ;
15898 PyObject *swig_obj[1] ;
15899
15900 if (!args) SWIG_fail;
15901 swig_obj[0] = args;
15902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15903 if (!SWIG_IsOK(res1)) {
15904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15905 }
15906 arg1 = reinterpret_cast< wxImage * >(argp1);
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (byte)(arg1)->GetMaskBlue();
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxImage *arg1 = (wxImage *) 0 ;
15923 bool arg2 = (bool) true ;
15924 void *argp1 = 0 ;
15925 int res1 = 0 ;
15926 bool val2 ;
15927 int ecode2 = 0 ;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 char * kwnames[] = {
15931 (char *) "self",(char *) "mask", NULL
15932 };
15933
15934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15938 }
15939 arg1 = reinterpret_cast< wxImage * >(argp1);
15940 if (obj1) {
15941 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15942 if (!SWIG_IsOK(ecode2)) {
15943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15944 }
15945 arg2 = static_cast< bool >(val2);
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 (arg1)->SetMask(arg2);
15950 wxPyEndAllowThreads(__tstate);
15951 if (PyErr_Occurred()) SWIG_fail;
15952 }
15953 resultobj = SWIG_Py_Void();
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15961 PyObject *resultobj = 0;
15962 wxImage *arg1 = (wxImage *) 0 ;
15963 bool result;
15964 void *argp1 = 0 ;
15965 int res1 = 0 ;
15966 PyObject *swig_obj[1] ;
15967
15968 if (!args) SWIG_fail;
15969 swig_obj[0] = args;
15970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15971 if (!SWIG_IsOK(res1)) {
15972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15973 }
15974 arg1 = reinterpret_cast< wxImage * >(argp1);
15975 {
15976 PyThreadState* __tstate = wxPyBeginAllowThreads();
15977 result = (bool)(arg1)->HasMask();
15978 wxPyEndAllowThreads(__tstate);
15979 if (PyErr_Occurred()) SWIG_fail;
15980 }
15981 {
15982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15983 }
15984 return resultobj;
15985 fail:
15986 return NULL;
15987 }
15988
15989
15990 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15991 PyObject *resultobj = 0;
15992 wxImage *arg1 = (wxImage *) 0 ;
15993 double arg2 ;
15994 wxPoint *arg3 = 0 ;
15995 bool arg4 = (bool) true ;
15996 wxPoint *arg5 = (wxPoint *) NULL ;
15997 SwigValueWrapper<wxImage > result;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 double val2 ;
16001 int ecode2 = 0 ;
16002 wxPoint temp3 ;
16003 bool val4 ;
16004 int ecode4 = 0 ;
16005 void *argp5 = 0 ;
16006 int res5 = 0 ;
16007 PyObject * obj0 = 0 ;
16008 PyObject * obj1 = 0 ;
16009 PyObject * obj2 = 0 ;
16010 PyObject * obj3 = 0 ;
16011 PyObject * obj4 = 0 ;
16012 char * kwnames[] = {
16013 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16014 };
16015
16016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16018 if (!SWIG_IsOK(res1)) {
16019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16020 }
16021 arg1 = reinterpret_cast< wxImage * >(argp1);
16022 ecode2 = SWIG_AsVal_double(obj1, &val2);
16023 if (!SWIG_IsOK(ecode2)) {
16024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16025 }
16026 arg2 = static_cast< double >(val2);
16027 {
16028 arg3 = &temp3;
16029 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16030 }
16031 if (obj3) {
16032 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16033 if (!SWIG_IsOK(ecode4)) {
16034 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16035 }
16036 arg4 = static_cast< bool >(val4);
16037 }
16038 if (obj4) {
16039 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16040 if (!SWIG_IsOK(res5)) {
16041 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16042 }
16043 arg5 = reinterpret_cast< wxPoint * >(argp5);
16044 }
16045 {
16046 PyThreadState* __tstate = wxPyBeginAllowThreads();
16047 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16048 wxPyEndAllowThreads(__tstate);
16049 if (PyErr_Occurred()) SWIG_fail;
16050 }
16051 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16052 return resultobj;
16053 fail:
16054 return NULL;
16055 }
16056
16057
16058 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16059 PyObject *resultobj = 0;
16060 wxImage *arg1 = (wxImage *) 0 ;
16061 bool arg2 = (bool) true ;
16062 SwigValueWrapper<wxImage > result;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 bool val2 ;
16066 int ecode2 = 0 ;
16067 PyObject * obj0 = 0 ;
16068 PyObject * obj1 = 0 ;
16069 char * kwnames[] = {
16070 (char *) "self",(char *) "clockwise", NULL
16071 };
16072
16073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16075 if (!SWIG_IsOK(res1)) {
16076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16077 }
16078 arg1 = reinterpret_cast< wxImage * >(argp1);
16079 if (obj1) {
16080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16081 if (!SWIG_IsOK(ecode2)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16083 }
16084 arg2 = static_cast< bool >(val2);
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = (arg1)->Rotate90(arg2);
16089 wxPyEndAllowThreads(__tstate);
16090 if (PyErr_Occurred()) SWIG_fail;
16091 }
16092 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16093 return resultobj;
16094 fail:
16095 return NULL;
16096 }
16097
16098
16099 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj = 0;
16101 wxImage *arg1 = (wxImage *) 0 ;
16102 bool arg2 = (bool) true ;
16103 SwigValueWrapper<wxImage > result;
16104 void *argp1 = 0 ;
16105 int res1 = 0 ;
16106 bool val2 ;
16107 int ecode2 = 0 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 char * kwnames[] = {
16111 (char *) "self",(char *) "horizontally", NULL
16112 };
16113
16114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16116 if (!SWIG_IsOK(res1)) {
16117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16118 }
16119 arg1 = reinterpret_cast< wxImage * >(argp1);
16120 if (obj1) {
16121 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16122 if (!SWIG_IsOK(ecode2)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16124 }
16125 arg2 = static_cast< bool >(val2);
16126 }
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 result = (arg1)->Mirror(arg2);
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj = 0;
16142 wxImage *arg1 = (wxImage *) 0 ;
16143 byte arg2 ;
16144 byte arg3 ;
16145 byte arg4 ;
16146 byte arg5 ;
16147 byte arg6 ;
16148 byte arg7 ;
16149 void *argp1 = 0 ;
16150 int res1 = 0 ;
16151 unsigned char val2 ;
16152 int ecode2 = 0 ;
16153 unsigned char val3 ;
16154 int ecode3 = 0 ;
16155 unsigned char val4 ;
16156 int ecode4 = 0 ;
16157 unsigned char val5 ;
16158 int ecode5 = 0 ;
16159 unsigned char val6 ;
16160 int ecode6 = 0 ;
16161 unsigned char val7 ;
16162 int ecode7 = 0 ;
16163 PyObject * obj0 = 0 ;
16164 PyObject * obj1 = 0 ;
16165 PyObject * obj2 = 0 ;
16166 PyObject * obj3 = 0 ;
16167 PyObject * obj4 = 0 ;
16168 PyObject * obj5 = 0 ;
16169 PyObject * obj6 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16181 if (!SWIG_IsOK(ecode2)) {
16182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16183 }
16184 arg2 = static_cast< byte >(val2);
16185 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16186 if (!SWIG_IsOK(ecode3)) {
16187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16188 }
16189 arg3 = static_cast< byte >(val3);
16190 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16191 if (!SWIG_IsOK(ecode4)) {
16192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16193 }
16194 arg4 = static_cast< byte >(val4);
16195 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16196 if (!SWIG_IsOK(ecode5)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16198 }
16199 arg5 = static_cast< byte >(val5);
16200 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16201 if (!SWIG_IsOK(ecode6)) {
16202 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16203 }
16204 arg6 = static_cast< byte >(val6);
16205 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16206 if (!SWIG_IsOK(ecode7)) {
16207 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16208 }
16209 arg7 = static_cast< byte >(val7);
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_Py_Void();
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj = 0;
16225 wxImage *arg1 = (wxImage *) 0 ;
16226 double arg2 = (double) 0.299 ;
16227 double arg3 = (double) 0.587 ;
16228 double arg4 = (double) 0.114 ;
16229 SwigValueWrapper<wxImage > result;
16230 void *argp1 = 0 ;
16231 int res1 = 0 ;
16232 double val2 ;
16233 int ecode2 = 0 ;
16234 double val3 ;
16235 int ecode3 = 0 ;
16236 double val4 ;
16237 int ecode4 = 0 ;
16238 PyObject * obj0 = 0 ;
16239 PyObject * obj1 = 0 ;
16240 PyObject * obj2 = 0 ;
16241 PyObject * obj3 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16248 if (!SWIG_IsOK(res1)) {
16249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16250 }
16251 arg1 = reinterpret_cast< wxImage * >(argp1);
16252 if (obj1) {
16253 ecode2 = SWIG_AsVal_double(obj1, &val2);
16254 if (!SWIG_IsOK(ecode2)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16256 }
16257 arg2 = static_cast< double >(val2);
16258 }
16259 if (obj2) {
16260 ecode3 = SWIG_AsVal_double(obj2, &val3);
16261 if (!SWIG_IsOK(ecode3)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16263 }
16264 arg3 = static_cast< double >(val3);
16265 }
16266 if (obj3) {
16267 ecode4 = SWIG_AsVal_double(obj3, &val4);
16268 if (!SWIG_IsOK(ecode4)) {
16269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16270 }
16271 arg4 = static_cast< double >(val4);
16272 }
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16287 PyObject *resultobj = 0;
16288 wxImage *arg1 = (wxImage *) 0 ;
16289 byte arg2 ;
16290 byte arg3 ;
16291 byte arg4 ;
16292 SwigValueWrapper<wxImage > result;
16293 void *argp1 = 0 ;
16294 int res1 = 0 ;
16295 unsigned char val2 ;
16296 int ecode2 = 0 ;
16297 unsigned char val3 ;
16298 int ecode3 = 0 ;
16299 unsigned char val4 ;
16300 int ecode4 = 0 ;
16301 PyObject * obj0 = 0 ;
16302 PyObject * obj1 = 0 ;
16303 PyObject * obj2 = 0 ;
16304 PyObject * obj3 = 0 ;
16305 char * kwnames[] = {
16306 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16307 };
16308
16309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16311 if (!SWIG_IsOK(res1)) {
16312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16313 }
16314 arg1 = reinterpret_cast< wxImage * >(argp1);
16315 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16316 if (!SWIG_IsOK(ecode2)) {
16317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16318 }
16319 arg2 = static_cast< byte >(val2);
16320 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16321 if (!SWIG_IsOK(ecode3)) {
16322 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16323 }
16324 arg3 = static_cast< byte >(val3);
16325 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16326 if (!SWIG_IsOK(ecode4)) {
16327 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16328 }
16329 arg4 = static_cast< byte >(val4);
16330 {
16331 PyThreadState* __tstate = wxPyBeginAllowThreads();
16332 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16333 wxPyEndAllowThreads(__tstate);
16334 if (PyErr_Occurred()) SWIG_fail;
16335 }
16336 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16337 return resultobj;
16338 fail:
16339 return NULL;
16340 }
16341
16342
16343 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16344 PyObject *resultobj = 0;
16345 wxImage *arg1 = (wxImage *) 0 ;
16346 wxString *arg2 = 0 ;
16347 wxString *arg3 = 0 ;
16348 void *argp1 = 0 ;
16349 int res1 = 0 ;
16350 bool temp2 = false ;
16351 bool temp3 = false ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 PyObject * obj2 = 0 ;
16355 char * kwnames[] = {
16356 (char *) "self",(char *) "name",(char *) "value", NULL
16357 };
16358
16359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16361 if (!SWIG_IsOK(res1)) {
16362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16363 }
16364 arg1 = reinterpret_cast< wxImage * >(argp1);
16365 {
16366 arg2 = wxString_in_helper(obj1);
16367 if (arg2 == NULL) SWIG_fail;
16368 temp2 = true;
16369 }
16370 {
16371 arg3 = wxString_in_helper(obj2);
16372 if (arg3 == NULL) SWIG_fail;
16373 temp3 = true;
16374 }
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16378 wxPyEndAllowThreads(__tstate);
16379 if (PyErr_Occurred()) SWIG_fail;
16380 }
16381 resultobj = SWIG_Py_Void();
16382 {
16383 if (temp2)
16384 delete arg2;
16385 }
16386 {
16387 if (temp3)
16388 delete arg3;
16389 }
16390 return resultobj;
16391 fail:
16392 {
16393 if (temp2)
16394 delete arg2;
16395 }
16396 {
16397 if (temp3)
16398 delete arg3;
16399 }
16400 return NULL;
16401 }
16402
16403
16404 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16405 PyObject *resultobj = 0;
16406 wxImage *arg1 = (wxImage *) 0 ;
16407 wxString *arg2 = 0 ;
16408 int arg3 ;
16409 void *argp1 = 0 ;
16410 int res1 = 0 ;
16411 bool temp2 = false ;
16412 int val3 ;
16413 int ecode3 = 0 ;
16414 PyObject * obj0 = 0 ;
16415 PyObject * obj1 = 0 ;
16416 PyObject * obj2 = 0 ;
16417 char * kwnames[] = {
16418 (char *) "self",(char *) "name",(char *) "value", NULL
16419 };
16420
16421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16423 if (!SWIG_IsOK(res1)) {
16424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16425 }
16426 arg1 = reinterpret_cast< wxImage * >(argp1);
16427 {
16428 arg2 = wxString_in_helper(obj1);
16429 if (arg2 == NULL) SWIG_fail;
16430 temp2 = true;
16431 }
16432 ecode3 = SWIG_AsVal_int(obj2, &val3);
16433 if (!SWIG_IsOK(ecode3)) {
16434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16435 }
16436 arg3 = static_cast< int >(val3);
16437 {
16438 PyThreadState* __tstate = wxPyBeginAllowThreads();
16439 (arg1)->SetOption((wxString const &)*arg2,arg3);
16440 wxPyEndAllowThreads(__tstate);
16441 if (PyErr_Occurred()) SWIG_fail;
16442 }
16443 resultobj = SWIG_Py_Void();
16444 {
16445 if (temp2)
16446 delete arg2;
16447 }
16448 return resultobj;
16449 fail:
16450 {
16451 if (temp2)
16452 delete arg2;
16453 }
16454 return NULL;
16455 }
16456
16457
16458 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj = 0;
16460 wxImage *arg1 = (wxImage *) 0 ;
16461 wxString *arg2 = 0 ;
16462 wxString result;
16463 void *argp1 = 0 ;
16464 int res1 = 0 ;
16465 bool temp2 = false ;
16466 PyObject * obj0 = 0 ;
16467 PyObject * obj1 = 0 ;
16468 char * kwnames[] = {
16469 (char *) "self",(char *) "name", NULL
16470 };
16471
16472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16474 if (!SWIG_IsOK(res1)) {
16475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16476 }
16477 arg1 = reinterpret_cast< wxImage * >(argp1);
16478 {
16479 arg2 = wxString_in_helper(obj1);
16480 if (arg2 == NULL) SWIG_fail;
16481 temp2 = true;
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16486 wxPyEndAllowThreads(__tstate);
16487 if (PyErr_Occurred()) SWIG_fail;
16488 }
16489 {
16490 #if wxUSE_UNICODE
16491 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16492 #else
16493 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16494 #endif
16495 }
16496 {
16497 if (temp2)
16498 delete arg2;
16499 }
16500 return resultobj;
16501 fail:
16502 {
16503 if (temp2)
16504 delete arg2;
16505 }
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 wxString *arg2 = 0 ;
16514 int result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 bool temp2 = false ;
16518 PyObject * obj0 = 0 ;
16519 PyObject * obj1 = 0 ;
16520 char * kwnames[] = {
16521 (char *) "self",(char *) "name", NULL
16522 };
16523
16524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16526 if (!SWIG_IsOK(res1)) {
16527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16528 }
16529 arg1 = reinterpret_cast< wxImage * >(argp1);
16530 {
16531 arg2 = wxString_in_helper(obj1);
16532 if (arg2 == NULL) SWIG_fail;
16533 temp2 = true;
16534 }
16535 {
16536 PyThreadState* __tstate = wxPyBeginAllowThreads();
16537 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16538 wxPyEndAllowThreads(__tstate);
16539 if (PyErr_Occurred()) SWIG_fail;
16540 }
16541 resultobj = SWIG_From_int(static_cast< int >(result));
16542 {
16543 if (temp2)
16544 delete arg2;
16545 }
16546 return resultobj;
16547 fail:
16548 {
16549 if (temp2)
16550 delete arg2;
16551 }
16552 return NULL;
16553 }
16554
16555
16556 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16557 PyObject *resultobj = 0;
16558 wxImage *arg1 = (wxImage *) 0 ;
16559 wxString *arg2 = 0 ;
16560 bool result;
16561 void *argp1 = 0 ;
16562 int res1 = 0 ;
16563 bool temp2 = false ;
16564 PyObject * obj0 = 0 ;
16565 PyObject * obj1 = 0 ;
16566 char * kwnames[] = {
16567 (char *) "self",(char *) "name", NULL
16568 };
16569
16570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16572 if (!SWIG_IsOK(res1)) {
16573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16574 }
16575 arg1 = reinterpret_cast< wxImage * >(argp1);
16576 {
16577 arg2 = wxString_in_helper(obj1);
16578 if (arg2 == NULL) SWIG_fail;
16579 temp2 = true;
16580 }
16581 {
16582 PyThreadState* __tstate = wxPyBeginAllowThreads();
16583 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16589 }
16590 {
16591 if (temp2)
16592 delete arg2;
16593 }
16594 return resultobj;
16595 fail:
16596 {
16597 if (temp2)
16598 delete arg2;
16599 }
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj = 0;
16606 wxImage *arg1 = (wxImage *) 0 ;
16607 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16608 unsigned long result;
16609 void *argp1 = 0 ;
16610 int res1 = 0 ;
16611 unsigned long val2 ;
16612 int ecode2 = 0 ;
16613 PyObject * obj0 = 0 ;
16614 PyObject * obj1 = 0 ;
16615 char * kwnames[] = {
16616 (char *) "self",(char *) "stopafter", NULL
16617 };
16618
16619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16621 if (!SWIG_IsOK(res1)) {
16622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16623 }
16624 arg1 = reinterpret_cast< wxImage * >(argp1);
16625 if (obj1) {
16626 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16627 if (!SWIG_IsOK(ecode2)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16629 }
16630 arg2 = static_cast< unsigned long >(val2);
16631 }
16632 {
16633 PyThreadState* __tstate = wxPyBeginAllowThreads();
16634 result = (unsigned long)(arg1)->CountColours(arg2);
16635 wxPyEndAllowThreads(__tstate);
16636 if (PyErr_Occurred()) SWIG_fail;
16637 }
16638 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj = 0;
16647 wxImage *arg1 = (wxImage *) 0 ;
16648 wxImageHistogram *arg2 = 0 ;
16649 unsigned long result;
16650 void *argp1 = 0 ;
16651 int res1 = 0 ;
16652 void *argp2 = 0 ;
16653 int res2 = 0 ;
16654 PyObject * obj0 = 0 ;
16655 PyObject * obj1 = 0 ;
16656 char * kwnames[] = {
16657 (char *) "self",(char *) "h", NULL
16658 };
16659
16660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16662 if (!SWIG_IsOK(res1)) {
16663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16664 }
16665 arg1 = reinterpret_cast< wxImage * >(argp1);
16666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16667 if (!SWIG_IsOK(res2)) {
16668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16669 }
16670 if (!argp2) {
16671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16672 }
16673 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16681 return resultobj;
16682 fail:
16683 return NULL;
16684 }
16685
16686
16687 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16688 PyObject *resultobj = 0;
16689 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 PyObject * obj0 = 0 ;
16693 char * kwnames[] = {
16694 (char *) "handler", NULL
16695 };
16696
16697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16699 if (!SWIG_IsOK(res1)) {
16700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16701 }
16702 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16703 {
16704 PyThreadState* __tstate = wxPyBeginAllowThreads();
16705 wxImage::AddHandler(arg1);
16706 wxPyEndAllowThreads(__tstate);
16707 if (PyErr_Occurred()) SWIG_fail;
16708 }
16709 resultobj = SWIG_Py_Void();
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj = 0;
16718 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16719 void *argp1 = 0 ;
16720 int res1 = 0 ;
16721 PyObject * obj0 = 0 ;
16722 char * kwnames[] = {
16723 (char *) "handler", NULL
16724 };
16725
16726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16730 }
16731 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 wxImage::InsertHandler(arg1);
16735 wxPyEndAllowThreads(__tstate);
16736 if (PyErr_Occurred()) SWIG_fail;
16737 }
16738 resultobj = SWIG_Py_Void();
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj = 0;
16747 wxString *arg1 = 0 ;
16748 bool result;
16749 bool temp1 = false ;
16750 PyObject * obj0 = 0 ;
16751 char * kwnames[] = {
16752 (char *) "name", NULL
16753 };
16754
16755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16756 {
16757 arg1 = wxString_in_helper(obj0);
16758 if (arg1 == NULL) SWIG_fail;
16759 temp1 = true;
16760 }
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 {
16768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16769 }
16770 {
16771 if (temp1)
16772 delete arg1;
16773 }
16774 return resultobj;
16775 fail:
16776 {
16777 if (temp1)
16778 delete arg1;
16779 }
16780 return NULL;
16781 }
16782
16783
16784 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16785 PyObject *resultobj = 0;
16786 PyObject *result = 0 ;
16787
16788 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16789 {
16790 PyThreadState* __tstate = wxPyBeginAllowThreads();
16791 result = (PyObject *)wxImage_GetHandlers();
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 resultobj = result;
16796 return resultobj;
16797 fail:
16798 return NULL;
16799 }
16800
16801
16802 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16803 PyObject *resultobj = 0;
16804 wxString result;
16805
16806 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16807 {
16808 PyThreadState* __tstate = wxPyBeginAllowThreads();
16809 result = wxImage::GetImageExtWildcard();
16810 wxPyEndAllowThreads(__tstate);
16811 if (PyErr_Occurred()) SWIG_fail;
16812 }
16813 {
16814 #if wxUSE_UNICODE
16815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16816 #else
16817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16818 #endif
16819 }
16820 return resultobj;
16821 fail:
16822 return NULL;
16823 }
16824
16825
16826 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj = 0;
16828 wxImage *arg1 = (wxImage *) 0 ;
16829 int arg2 = (int) -1 ;
16830 wxBitmap result;
16831 void *argp1 = 0 ;
16832 int res1 = 0 ;
16833 int val2 ;
16834 int ecode2 = 0 ;
16835 PyObject * obj0 = 0 ;
16836 PyObject * obj1 = 0 ;
16837 char * kwnames[] = {
16838 (char *) "self",(char *) "depth", NULL
16839 };
16840
16841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16843 if (!SWIG_IsOK(res1)) {
16844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16845 }
16846 arg1 = reinterpret_cast< wxImage * >(argp1);
16847 if (obj1) {
16848 ecode2 = SWIG_AsVal_int(obj1, &val2);
16849 if (!SWIG_IsOK(ecode2)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16851 }
16852 arg2 = static_cast< int >(val2);
16853 }
16854 {
16855 if (!wxPyCheckForApp()) SWIG_fail;
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = wxImage_ConvertToBitmap(arg1,arg2);
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16862 return resultobj;
16863 fail:
16864 return NULL;
16865 }
16866
16867
16868 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj = 0;
16870 wxImage *arg1 = (wxImage *) 0 ;
16871 byte arg2 ;
16872 byte arg3 ;
16873 byte arg4 ;
16874 wxBitmap result;
16875 void *argp1 = 0 ;
16876 int res1 = 0 ;
16877 unsigned char val2 ;
16878 int ecode2 = 0 ;
16879 unsigned char val3 ;
16880 int ecode3 = 0 ;
16881 unsigned char val4 ;
16882 int ecode4 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 PyObject * obj1 = 0 ;
16885 PyObject * obj2 = 0 ;
16886 PyObject * obj3 = 0 ;
16887 char * kwnames[] = {
16888 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16889 };
16890
16891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16895 }
16896 arg1 = reinterpret_cast< wxImage * >(argp1);
16897 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16898 if (!SWIG_IsOK(ecode2)) {
16899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16900 }
16901 arg2 = static_cast< byte >(val2);
16902 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16903 if (!SWIG_IsOK(ecode3)) {
16904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16905 }
16906 arg3 = static_cast< byte >(val3);
16907 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16908 if (!SWIG_IsOK(ecode4)) {
16909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16910 }
16911 arg4 = static_cast< byte >(val4);
16912 {
16913 if (!wxPyCheckForApp()) SWIG_fail;
16914 PyThreadState* __tstate = wxPyBeginAllowThreads();
16915 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16916 wxPyEndAllowThreads(__tstate);
16917 if (PyErr_Occurred()) SWIG_fail;
16918 }
16919 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16920 return resultobj;
16921 fail:
16922 return NULL;
16923 }
16924
16925
16926 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16927 PyObject *resultobj = 0;
16928 wxImage *arg1 = (wxImage *) 0 ;
16929 double arg2 ;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 double val2 ;
16933 int ecode2 = 0 ;
16934 PyObject * obj0 = 0 ;
16935 PyObject * obj1 = 0 ;
16936 char * kwnames[] = {
16937 (char *) "self",(char *) "angle", NULL
16938 };
16939
16940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16942 if (!SWIG_IsOK(res1)) {
16943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16944 }
16945 arg1 = reinterpret_cast< wxImage * >(argp1);
16946 ecode2 = SWIG_AsVal_double(obj1, &val2);
16947 if (!SWIG_IsOK(ecode2)) {
16948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16949 }
16950 arg2 = static_cast< double >(val2);
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 (arg1)->RotateHue(arg2);
16954 wxPyEndAllowThreads(__tstate);
16955 if (PyErr_Occurred()) SWIG_fail;
16956 }
16957 resultobj = SWIG_Py_Void();
16958 return resultobj;
16959 fail:
16960 return NULL;
16961 }
16962
16963
16964 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16965 PyObject *resultobj = 0;
16966 wxImage_RGBValue arg1 ;
16967 wxImage_HSVValue result;
16968 void *argp1 ;
16969 int res1 = 0 ;
16970 PyObject * obj0 = 0 ;
16971 char * kwnames[] = {
16972 (char *) "rgb", NULL
16973 };
16974
16975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16976 {
16977 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16978 if (!SWIG_IsOK(res1)) {
16979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16980 }
16981 if (!argp1) {
16982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16983 } else {
16984 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16985 arg1 = *temp;
16986 if (SWIG_IsNewObj(res1)) delete temp;
16987 }
16988 }
16989 {
16990 PyThreadState* __tstate = wxPyBeginAllowThreads();
16991 result = wxImage::RGBtoHSV(arg1);
16992 wxPyEndAllowThreads(__tstate);
16993 if (PyErr_Occurred()) SWIG_fail;
16994 }
16995 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxImage_HSVValue arg1 ;
17005 wxImage_RGBValue result;
17006 void *argp1 ;
17007 int res1 = 0 ;
17008 PyObject * obj0 = 0 ;
17009 char * kwnames[] = {
17010 (char *) "hsv", NULL
17011 };
17012
17013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17014 {
17015 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17016 if (!SWIG_IsOK(res1)) {
17017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17018 }
17019 if (!argp1) {
17020 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17021 } else {
17022 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17023 arg1 = *temp;
17024 if (SWIG_IsNewObj(res1)) delete temp;
17025 }
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 result = wxImage::HSVtoRGB(arg1);
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17034 return resultobj;
17035 fail:
17036 return NULL;
17037 }
17038
17039
17040 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17041 PyObject *obj;
17042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17043 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17044 return SWIG_Py_Void();
17045 }
17046
17047 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17048 return SWIG_Python_InitShadowInstance(args);
17049 }
17050
17051 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = 0;
17053 int arg1 ;
17054 int arg2 ;
17055 buffer arg3 ;
17056 int arg4 ;
17057 buffer arg5 = (buffer) NULL ;
17058 int arg6 = (int) 0 ;
17059 wxImage *result = 0 ;
17060 int val1 ;
17061 int ecode1 = 0 ;
17062 int val2 ;
17063 int ecode2 = 0 ;
17064 PyObject * obj0 = 0 ;
17065 PyObject * obj1 = 0 ;
17066 PyObject * obj2 = 0 ;
17067 PyObject * obj3 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17073 ecode1 = SWIG_AsVal_int(obj0, &val1);
17074 if (!SWIG_IsOK(ecode1)) {
17075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17076 }
17077 arg1 = static_cast< int >(val1);
17078 ecode2 = SWIG_AsVal_int(obj1, &val2);
17079 if (!SWIG_IsOK(ecode2)) {
17080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17081 }
17082 arg2 = static_cast< int >(val2);
17083 {
17084 if (obj2 != Py_None) {
17085 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
17086 }
17087 }
17088 if (obj3) {
17089 {
17090 if (obj3 != Py_None) {
17091 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
17092 }
17093 }
17094 }
17095 {
17096 PyThreadState* __tstate = wxPyBeginAllowThreads();
17097 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17098 wxPyEndAllowThreads(__tstate);
17099 if (PyErr_Occurred()) SWIG_fail;
17100 }
17101 {
17102 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17103 }
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 SWIGINTERN int NullImage_set(PyObject *) {
17111 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17112 return 1;
17113 }
17114
17115
17116 SWIGINTERN PyObject *NullImage_get(void) {
17117 PyObject *pyobj = 0;
17118
17119 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17120 return pyobj;
17121 }
17122
17123
17124 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17125 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17126 return 1;
17127 }
17128
17129
17130 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17131 PyObject *pyobj = 0;
17132
17133 {
17134 #if wxUSE_UNICODE
17135 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17136 #else
17137 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17138 #endif
17139 }
17140 return pyobj;
17141 }
17142
17143
17144 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17145 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17146 return 1;
17147 }
17148
17149
17150 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17151 PyObject *pyobj = 0;
17152
17153 {
17154 #if wxUSE_UNICODE
17155 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17156 #else
17157 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17158 #endif
17159 }
17160 return pyobj;
17161 }
17162
17163
17164 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17165 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17166 return 1;
17167 }
17168
17169
17170 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17171 PyObject *pyobj = 0;
17172
17173 {
17174 #if wxUSE_UNICODE
17175 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17176 #else
17177 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17178 #endif
17179 }
17180 return pyobj;
17181 }
17182
17183
17184 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17185 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17186 return 1;
17187 }
17188
17189
17190 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17191 PyObject *pyobj = 0;
17192
17193 {
17194 #if wxUSE_UNICODE
17195 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17196 #else
17197 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17198 #endif
17199 }
17200 return pyobj;
17201 }
17202
17203
17204 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17205 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17206 return 1;
17207 }
17208
17209
17210 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17211 PyObject *pyobj = 0;
17212
17213 {
17214 #if wxUSE_UNICODE
17215 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17216 #else
17217 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17218 #endif
17219 }
17220 return pyobj;
17221 }
17222
17223
17224 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17225 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17226 return 1;
17227 }
17228
17229
17230 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17231 PyObject *pyobj = 0;
17232
17233 {
17234 #if wxUSE_UNICODE
17235 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17236 #else
17237 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17238 #endif
17239 }
17240 return pyobj;
17241 }
17242
17243
17244 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17245 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17246 return 1;
17247 }
17248
17249
17250 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17251 PyObject *pyobj = 0;
17252
17253 {
17254 #if wxUSE_UNICODE
17255 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17256 #else
17257 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17258 #endif
17259 }
17260 return pyobj;
17261 }
17262
17263
17264 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17265 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17266 return 1;
17267 }
17268
17269
17270 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17271 PyObject *pyobj = 0;
17272
17273 {
17274 #if wxUSE_UNICODE
17275 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17276 #else
17277 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17278 #endif
17279 }
17280 return pyobj;
17281 }
17282
17283
17284 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17285 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17286 return 1;
17287 }
17288
17289
17290 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17291 PyObject *pyobj = 0;
17292
17293 {
17294 #if wxUSE_UNICODE
17295 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17296 #else
17297 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17298 #endif
17299 }
17300 return pyobj;
17301 }
17302
17303
17304 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17305 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17306 return 1;
17307 }
17308
17309
17310 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17311 PyObject *pyobj = 0;
17312
17313 {
17314 #if wxUSE_UNICODE
17315 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17316 #else
17317 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17318 #endif
17319 }
17320 return pyobj;
17321 }
17322
17323
17324 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17325 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17326 return 1;
17327 }
17328
17329
17330 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17331 PyObject *pyobj = 0;
17332
17333 {
17334 #if wxUSE_UNICODE
17335 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17336 #else
17337 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17338 #endif
17339 }
17340 return pyobj;
17341 }
17342
17343
17344 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17345 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17346 return 1;
17347 }
17348
17349
17350 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17351 PyObject *pyobj = 0;
17352
17353 {
17354 #if wxUSE_UNICODE
17355 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17356 #else
17357 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17358 #endif
17359 }
17360 return pyobj;
17361 }
17362
17363
17364 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17365 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17366 return 1;
17367 }
17368
17369
17370 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17371 PyObject *pyobj = 0;
17372
17373 {
17374 #if wxUSE_UNICODE
17375 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17376 #else
17377 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17378 #endif
17379 }
17380 return pyobj;
17381 }
17382
17383
17384 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17385 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17386 return 1;
17387 }
17388
17389
17390 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17391 PyObject *pyobj = 0;
17392
17393 {
17394 #if wxUSE_UNICODE
17395 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17396 #else
17397 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17398 #endif
17399 }
17400 return pyobj;
17401 }
17402
17403
17404 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17405 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17406 return 1;
17407 }
17408
17409
17410 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17411 PyObject *pyobj = 0;
17412
17413 {
17414 #if wxUSE_UNICODE
17415 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17416 #else
17417 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17418 #endif
17419 }
17420 return pyobj;
17421 }
17422
17423
17424 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17425 PyObject *resultobj = 0;
17426 wxBMPHandler *result = 0 ;
17427
17428 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17429 {
17430 PyThreadState* __tstate = wxPyBeginAllowThreads();
17431 result = (wxBMPHandler *)new wxBMPHandler();
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *obj;
17444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17445 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17446 return SWIG_Py_Void();
17447 }
17448
17449 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17450 return SWIG_Python_InitShadowInstance(args);
17451 }
17452
17453 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17454 PyObject *resultobj = 0;
17455 wxICOHandler *result = 0 ;
17456
17457 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17458 {
17459 PyThreadState* __tstate = wxPyBeginAllowThreads();
17460 result = (wxICOHandler *)new wxICOHandler();
17461 wxPyEndAllowThreads(__tstate);
17462 if (PyErr_Occurred()) SWIG_fail;
17463 }
17464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17465 return resultobj;
17466 fail:
17467 return NULL;
17468 }
17469
17470
17471 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 PyObject *obj;
17473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17474 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17475 return SWIG_Py_Void();
17476 }
17477
17478 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17479 return SWIG_Python_InitShadowInstance(args);
17480 }
17481
17482 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17483 PyObject *resultobj = 0;
17484 wxCURHandler *result = 0 ;
17485
17486 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17487 {
17488 PyThreadState* __tstate = wxPyBeginAllowThreads();
17489 result = (wxCURHandler *)new wxCURHandler();
17490 wxPyEndAllowThreads(__tstate);
17491 if (PyErr_Occurred()) SWIG_fail;
17492 }
17493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17494 return resultobj;
17495 fail:
17496 return NULL;
17497 }
17498
17499
17500 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17501 PyObject *obj;
17502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17503 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17504 return SWIG_Py_Void();
17505 }
17506
17507 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17508 return SWIG_Python_InitShadowInstance(args);
17509 }
17510
17511 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17512 PyObject *resultobj = 0;
17513 wxANIHandler *result = 0 ;
17514
17515 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17516 {
17517 PyThreadState* __tstate = wxPyBeginAllowThreads();
17518 result = (wxANIHandler *)new wxANIHandler();
17519 wxPyEndAllowThreads(__tstate);
17520 if (PyErr_Occurred()) SWIG_fail;
17521 }
17522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17523 return resultobj;
17524 fail:
17525 return NULL;
17526 }
17527
17528
17529 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17530 PyObject *obj;
17531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17532 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17533 return SWIG_Py_Void();
17534 }
17535
17536 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17537 return SWIG_Python_InitShadowInstance(args);
17538 }
17539
17540 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17541 PyObject *resultobj = 0;
17542 wxPNGHandler *result = 0 ;
17543
17544 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17545 {
17546 PyThreadState* __tstate = wxPyBeginAllowThreads();
17547 result = (wxPNGHandler *)new wxPNGHandler();
17548 wxPyEndAllowThreads(__tstate);
17549 if (PyErr_Occurred()) SWIG_fail;
17550 }
17551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17552 return resultobj;
17553 fail:
17554 return NULL;
17555 }
17556
17557
17558 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17559 PyObject *obj;
17560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17561 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17562 return SWIG_Py_Void();
17563 }
17564
17565 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17566 return SWIG_Python_InitShadowInstance(args);
17567 }
17568
17569 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17570 PyObject *resultobj = 0;
17571 wxGIFHandler *result = 0 ;
17572
17573 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 result = (wxGIFHandler *)new wxGIFHandler();
17577 wxPyEndAllowThreads(__tstate);
17578 if (PyErr_Occurred()) SWIG_fail;
17579 }
17580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17581 return resultobj;
17582 fail:
17583 return NULL;
17584 }
17585
17586
17587 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17588 PyObject *obj;
17589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17590 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17591 return SWIG_Py_Void();
17592 }
17593
17594 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17595 return SWIG_Python_InitShadowInstance(args);
17596 }
17597
17598 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 PyObject *resultobj = 0;
17600 wxPCXHandler *result = 0 ;
17601
17602 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17603 {
17604 PyThreadState* __tstate = wxPyBeginAllowThreads();
17605 result = (wxPCXHandler *)new wxPCXHandler();
17606 wxPyEndAllowThreads(__tstate);
17607 if (PyErr_Occurred()) SWIG_fail;
17608 }
17609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17610 return resultobj;
17611 fail:
17612 return NULL;
17613 }
17614
17615
17616 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17617 PyObject *obj;
17618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17619 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17620 return SWIG_Py_Void();
17621 }
17622
17623 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17624 return SWIG_Python_InitShadowInstance(args);
17625 }
17626
17627 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17628 PyObject *resultobj = 0;
17629 wxJPEGHandler *result = 0 ;
17630
17631 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (wxJPEGHandler *)new wxJPEGHandler();
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17639 return resultobj;
17640 fail:
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17646 PyObject *obj;
17647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17648 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17649 return SWIG_Py_Void();
17650 }
17651
17652 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17653 return SWIG_Python_InitShadowInstance(args);
17654 }
17655
17656 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17657 PyObject *resultobj = 0;
17658 wxPNMHandler *result = 0 ;
17659
17660 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (wxPNMHandler *)new wxPNMHandler();
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17668 return resultobj;
17669 fail:
17670 return NULL;
17671 }
17672
17673
17674 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17675 PyObject *obj;
17676 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17677 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17678 return SWIG_Py_Void();
17679 }
17680
17681 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17682 return SWIG_Python_InitShadowInstance(args);
17683 }
17684
17685 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17686 PyObject *resultobj = 0;
17687 wxXPMHandler *result = 0 ;
17688
17689 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17690 {
17691 PyThreadState* __tstate = wxPyBeginAllowThreads();
17692 result = (wxXPMHandler *)new wxXPMHandler();
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17704 PyObject *obj;
17705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17706 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17707 return SWIG_Py_Void();
17708 }
17709
17710 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17711 return SWIG_Python_InitShadowInstance(args);
17712 }
17713
17714 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17715 PyObject *resultobj = 0;
17716 wxTIFFHandler *result = 0 ;
17717
17718 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17719 {
17720 PyThreadState* __tstate = wxPyBeginAllowThreads();
17721 result = (wxTIFFHandler *)new wxTIFFHandler();
17722 wxPyEndAllowThreads(__tstate);
17723 if (PyErr_Occurred()) SWIG_fail;
17724 }
17725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17733 PyObject *obj;
17734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17735 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17736 return SWIG_Py_Void();
17737 }
17738
17739 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17740 return SWIG_Python_InitShadowInstance(args);
17741 }
17742
17743 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17744 PyObject *resultobj = 0;
17745 wxImage *arg1 = 0 ;
17746 wxImage *arg2 = 0 ;
17747 int arg3 = (int) 236 ;
17748 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17749 bool result;
17750 void *argp1 = 0 ;
17751 int res1 = 0 ;
17752 void *argp2 = 0 ;
17753 int res2 = 0 ;
17754 int val3 ;
17755 int ecode3 = 0 ;
17756 int val4 ;
17757 int ecode4 = 0 ;
17758 PyObject * obj0 = 0 ;
17759 PyObject * obj1 = 0 ;
17760 PyObject * obj2 = 0 ;
17761 PyObject * obj3 = 0 ;
17762 char * kwnames[] = {
17763 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17764 };
17765
17766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17767 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17768 if (!SWIG_IsOK(res1)) {
17769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17770 }
17771 if (!argp1) {
17772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17773 }
17774 arg1 = reinterpret_cast< wxImage * >(argp1);
17775 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17776 if (!SWIG_IsOK(res2)) {
17777 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17778 }
17779 if (!argp2) {
17780 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17781 }
17782 arg2 = reinterpret_cast< wxImage * >(argp2);
17783 if (obj2) {
17784 ecode3 = SWIG_AsVal_int(obj2, &val3);
17785 if (!SWIG_IsOK(ecode3)) {
17786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17787 }
17788 arg3 = static_cast< int >(val3);
17789 }
17790 if (obj3) {
17791 ecode4 = SWIG_AsVal_int(obj3, &val4);
17792 if (!SWIG_IsOK(ecode4)) {
17793 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17794 }
17795 arg4 = static_cast< int >(val4);
17796 }
17797 {
17798 PyThreadState* __tstate = wxPyBeginAllowThreads();
17799 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 {
17804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17805 }
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17813 PyObject *obj;
17814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17815 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17816 return SWIG_Py_Void();
17817 }
17818
17819 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17820 PyObject *resultobj = 0;
17821 wxEvtHandler *result = 0 ;
17822
17823 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 result = (wxEvtHandler *)new wxEvtHandler();
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17831 return resultobj;
17832 fail:
17833 return NULL;
17834 }
17835
17836
17837 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17838 PyObject *resultobj = 0;
17839 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17840 wxEvtHandler *result = 0 ;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 PyObject *swig_obj[1] ;
17844
17845 if (!args) SWIG_fail;
17846 swig_obj[0] = args;
17847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17848 if (!SWIG_IsOK(res1)) {
17849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17850 }
17851 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17852 {
17853 PyThreadState* __tstate = wxPyBeginAllowThreads();
17854 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17855 wxPyEndAllowThreads(__tstate);
17856 if (PyErr_Occurred()) SWIG_fail;
17857 }
17858 {
17859 resultobj = wxPyMake_wxObject(result, 0);
17860 }
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17868 PyObject *resultobj = 0;
17869 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17870 wxEvtHandler *result = 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_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17880 }
17881 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17882 {
17883 PyThreadState* __tstate = wxPyBeginAllowThreads();
17884 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = wxPyMake_wxObject(result, 0);
17890 }
17891 return resultobj;
17892 fail:
17893 return NULL;
17894 }
17895
17896
17897 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17898 PyObject *resultobj = 0;
17899 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17900 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17901 void *argp1 = 0 ;
17902 int res1 = 0 ;
17903 void *argp2 = 0 ;
17904 int res2 = 0 ;
17905 PyObject * obj0 = 0 ;
17906 PyObject * obj1 = 0 ;
17907 char * kwnames[] = {
17908 (char *) "self",(char *) "handler", NULL
17909 };
17910
17911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17915 }
17916 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17918 if (!SWIG_IsOK(res2)) {
17919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17920 }
17921 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17922 {
17923 PyThreadState* __tstate = wxPyBeginAllowThreads();
17924 (arg1)->SetNextHandler(arg2);
17925 wxPyEndAllowThreads(__tstate);
17926 if (PyErr_Occurred()) SWIG_fail;
17927 }
17928 resultobj = SWIG_Py_Void();
17929 return resultobj;
17930 fail:
17931 return NULL;
17932 }
17933
17934
17935 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17936 PyObject *resultobj = 0;
17937 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17938 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17939 void *argp1 = 0 ;
17940 int res1 = 0 ;
17941 void *argp2 = 0 ;
17942 int res2 = 0 ;
17943 PyObject * obj0 = 0 ;
17944 PyObject * obj1 = 0 ;
17945 char * kwnames[] = {
17946 (char *) "self",(char *) "handler", NULL
17947 };
17948
17949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17951 if (!SWIG_IsOK(res1)) {
17952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17953 }
17954 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17956 if (!SWIG_IsOK(res2)) {
17957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17958 }
17959 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 (arg1)->SetPreviousHandler(arg2);
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 resultobj = SWIG_Py_Void();
17967 return resultobj;
17968 fail:
17969 return NULL;
17970 }
17971
17972
17973 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17974 PyObject *resultobj = 0;
17975 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17976 bool result;
17977 void *argp1 = 0 ;
17978 int res1 = 0 ;
17979 PyObject *swig_obj[1] ;
17980
17981 if (!args) SWIG_fail;
17982 swig_obj[0] = args;
17983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17984 if (!SWIG_IsOK(res1)) {
17985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17986 }
17987 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 result = (bool)(arg1)->GetEvtHandlerEnabled();
17991 wxPyEndAllowThreads(__tstate);
17992 if (PyErr_Occurred()) SWIG_fail;
17993 }
17994 {
17995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17996 }
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18004 PyObject *resultobj = 0;
18005 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18006 bool arg2 ;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 bool val2 ;
18010 int ecode2 = 0 ;
18011 PyObject * obj0 = 0 ;
18012 PyObject * obj1 = 0 ;
18013 char * kwnames[] = {
18014 (char *) "self",(char *) "enabled", NULL
18015 };
18016
18017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18019 if (!SWIG_IsOK(res1)) {
18020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18021 }
18022 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18023 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18024 if (!SWIG_IsOK(ecode2)) {
18025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18026 }
18027 arg2 = static_cast< bool >(val2);
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 (arg1)->SetEvtHandlerEnabled(arg2);
18031 wxPyEndAllowThreads(__tstate);
18032 if (PyErr_Occurred()) SWIG_fail;
18033 }
18034 resultobj = SWIG_Py_Void();
18035 return resultobj;
18036 fail:
18037 return NULL;
18038 }
18039
18040
18041 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18042 PyObject *resultobj = 0;
18043 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18044 wxEvent *arg2 = 0 ;
18045 bool result;
18046 void *argp1 = 0 ;
18047 int res1 = 0 ;
18048 void *argp2 = 0 ;
18049 int res2 = 0 ;
18050 PyObject * obj0 = 0 ;
18051 PyObject * obj1 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "event", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18058 if (!SWIG_IsOK(res1)) {
18059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18060 }
18061 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18062 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18063 if (!SWIG_IsOK(res2)) {
18064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18065 }
18066 if (!argp2) {
18067 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18068 }
18069 arg2 = reinterpret_cast< wxEvent * >(argp2);
18070 {
18071 PyThreadState* __tstate = wxPyBeginAllowThreads();
18072 result = (bool)(arg1)->ProcessEvent(*arg2);
18073 wxPyEndAllowThreads(__tstate);
18074 if (PyErr_Occurred()) SWIG_fail;
18075 }
18076 {
18077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18078 }
18079 return resultobj;
18080 fail:
18081 return NULL;
18082 }
18083
18084
18085 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18086 PyObject *resultobj = 0;
18087 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18088 wxEvent *arg2 = 0 ;
18089 void *argp1 = 0 ;
18090 int res1 = 0 ;
18091 void *argp2 = 0 ;
18092 int res2 = 0 ;
18093 PyObject * obj0 = 0 ;
18094 PyObject * obj1 = 0 ;
18095 char * kwnames[] = {
18096 (char *) "self",(char *) "event", NULL
18097 };
18098
18099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18101 if (!SWIG_IsOK(res1)) {
18102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18103 }
18104 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18106 if (!SWIG_IsOK(res2)) {
18107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18108 }
18109 if (!argp2) {
18110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18111 }
18112 arg2 = reinterpret_cast< wxEvent * >(argp2);
18113 {
18114 PyThreadState* __tstate = wxPyBeginAllowThreads();
18115 (arg1)->AddPendingEvent(*arg2);
18116 wxPyEndAllowThreads(__tstate);
18117 if (PyErr_Occurred()) SWIG_fail;
18118 }
18119 resultobj = SWIG_Py_Void();
18120 return resultobj;
18121 fail:
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18127 PyObject *resultobj = 0;
18128 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18129 void *argp1 = 0 ;
18130 int res1 = 0 ;
18131 PyObject *swig_obj[1] ;
18132
18133 if (!args) SWIG_fail;
18134 swig_obj[0] = args;
18135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18136 if (!SWIG_IsOK(res1)) {
18137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18138 }
18139 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 (arg1)->ProcessPendingEvents();
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_Py_Void();
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18154 PyObject *resultobj = 0;
18155 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18156 int arg2 ;
18157 int arg3 ;
18158 int arg4 ;
18159 PyObject *arg5 = (PyObject *) 0 ;
18160 void *argp1 = 0 ;
18161 int res1 = 0 ;
18162 int val2 ;
18163 int ecode2 = 0 ;
18164 int val3 ;
18165 int ecode3 = 0 ;
18166 int val4 ;
18167 int ecode4 = 0 ;
18168 PyObject * obj0 = 0 ;
18169 PyObject * obj1 = 0 ;
18170 PyObject * obj2 = 0 ;
18171 PyObject * obj3 = 0 ;
18172 PyObject * obj4 = 0 ;
18173 char * kwnames[] = {
18174 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18175 };
18176
18177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18179 if (!SWIG_IsOK(res1)) {
18180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18181 }
18182 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18183 ecode2 = SWIG_AsVal_int(obj1, &val2);
18184 if (!SWIG_IsOK(ecode2)) {
18185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18186 }
18187 arg2 = static_cast< int >(val2);
18188 ecode3 = SWIG_AsVal_int(obj2, &val3);
18189 if (!SWIG_IsOK(ecode3)) {
18190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18191 }
18192 arg3 = static_cast< int >(val3);
18193 ecode4 = SWIG_AsVal_int(obj3, &val4);
18194 if (!SWIG_IsOK(ecode4)) {
18195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18196 }
18197 arg4 = static_cast< int >(val4);
18198 arg5 = obj4;
18199 {
18200 PyThreadState* __tstate = wxPyBeginAllowThreads();
18201 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 resultobj = SWIG_Py_Void();
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj = 0;
18214 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18215 int arg2 ;
18216 int arg3 = (int) -1 ;
18217 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18218 bool result;
18219 void *argp1 = 0 ;
18220 int res1 = 0 ;
18221 int val2 ;
18222 int ecode2 = 0 ;
18223 int val3 ;
18224 int ecode3 = 0 ;
18225 int val4 ;
18226 int ecode4 = 0 ;
18227 PyObject * obj0 = 0 ;
18228 PyObject * obj1 = 0 ;
18229 PyObject * obj2 = 0 ;
18230 PyObject * obj3 = 0 ;
18231 char * kwnames[] = {
18232 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18233 };
18234
18235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18237 if (!SWIG_IsOK(res1)) {
18238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18239 }
18240 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18241 ecode2 = SWIG_AsVal_int(obj1, &val2);
18242 if (!SWIG_IsOK(ecode2)) {
18243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18244 }
18245 arg2 = static_cast< int >(val2);
18246 if (obj2) {
18247 ecode3 = SWIG_AsVal_int(obj2, &val3);
18248 if (!SWIG_IsOK(ecode3)) {
18249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18250 }
18251 arg3 = static_cast< int >(val3);
18252 }
18253 if (obj3) {
18254 ecode4 = SWIG_AsVal_int(obj3, &val4);
18255 if (!SWIG_IsOK(ecode4)) {
18256 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18257 }
18258 arg4 = static_cast< wxEventType >(val4);
18259 }
18260 {
18261 PyThreadState* __tstate = wxPyBeginAllowThreads();
18262 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj = 0;
18277 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18278 PyObject *arg2 = (PyObject *) 0 ;
18279 bool arg3 = (bool) true ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 bool val3 ;
18283 int ecode3 = 0 ;
18284 PyObject * obj0 = 0 ;
18285 PyObject * obj1 = 0 ;
18286 PyObject * obj2 = 0 ;
18287 char * kwnames[] = {
18288 (char *) "self",(char *) "_self",(char *) "incref", NULL
18289 };
18290
18291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18297 arg2 = obj1;
18298 if (obj2) {
18299 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18300 if (!SWIG_IsOK(ecode3)) {
18301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18302 }
18303 arg3 = static_cast< bool >(val3);
18304 }
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 resultobj = SWIG_Py_Void();
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18319 PyObject *obj;
18320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18321 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18322 return SWIG_Py_Void();
18323 }
18324
18325 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18326 return SWIG_Python_InitShadowInstance(args);
18327 }
18328
18329 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18330 PyObject *resultobj = 0;
18331 wxEventType result;
18332
18333 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = (wxEventType)wxNewEventType();
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_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18348 PyObject *resultobj = 0;
18349 wxEvent *arg1 = (wxEvent *) 0 ;
18350 void *argp1 = 0 ;
18351 int res1 = 0 ;
18352 PyObject *swig_obj[1] ;
18353
18354 if (!args) SWIG_fail;
18355 swig_obj[0] = args;
18356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18357 if (!SWIG_IsOK(res1)) {
18358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18359 }
18360 arg1 = reinterpret_cast< wxEvent * >(argp1);
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 delete arg1;
18364
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = SWIG_Py_Void();
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = 0;
18377 wxEvent *arg1 = (wxEvent *) 0 ;
18378 wxEventType arg2 ;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 int val2 ;
18382 int ecode2 = 0 ;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 char * kwnames[] = {
18386 (char *) "self",(char *) "typ", NULL
18387 };
18388
18389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18391 if (!SWIG_IsOK(res1)) {
18392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18393 }
18394 arg1 = reinterpret_cast< wxEvent * >(argp1);
18395 ecode2 = SWIG_AsVal_int(obj1, &val2);
18396 if (!SWIG_IsOK(ecode2)) {
18397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18398 }
18399 arg2 = static_cast< wxEventType >(val2);
18400 {
18401 PyThreadState* __tstate = wxPyBeginAllowThreads();
18402 (arg1)->SetEventType(arg2);
18403 wxPyEndAllowThreads(__tstate);
18404 if (PyErr_Occurred()) SWIG_fail;
18405 }
18406 resultobj = SWIG_Py_Void();
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18414 PyObject *resultobj = 0;
18415 wxEvent *arg1 = (wxEvent *) 0 ;
18416 wxEventType result;
18417 void *argp1 = 0 ;
18418 int res1 = 0 ;
18419 PyObject *swig_obj[1] ;
18420
18421 if (!args) SWIG_fail;
18422 swig_obj[0] = args;
18423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18424 if (!SWIG_IsOK(res1)) {
18425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18426 }
18427 arg1 = reinterpret_cast< wxEvent * >(argp1);
18428 {
18429 PyThreadState* __tstate = wxPyBeginAllowThreads();
18430 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18431 wxPyEndAllowThreads(__tstate);
18432 if (PyErr_Occurred()) SWIG_fail;
18433 }
18434 resultobj = SWIG_From_int(static_cast< int >(result));
18435 return resultobj;
18436 fail:
18437 return NULL;
18438 }
18439
18440
18441 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18442 PyObject *resultobj = 0;
18443 wxEvent *arg1 = (wxEvent *) 0 ;
18444 wxObject *result = 0 ;
18445 void *argp1 = 0 ;
18446 int res1 = 0 ;
18447 PyObject *swig_obj[1] ;
18448
18449 if (!args) SWIG_fail;
18450 swig_obj[0] = args;
18451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18452 if (!SWIG_IsOK(res1)) {
18453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18454 }
18455 arg1 = reinterpret_cast< wxEvent * >(argp1);
18456 {
18457 PyThreadState* __tstate = wxPyBeginAllowThreads();
18458 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18459 wxPyEndAllowThreads(__tstate);
18460 if (PyErr_Occurred()) SWIG_fail;
18461 }
18462 {
18463 resultobj = wxPyMake_wxObject(result, (bool)0);
18464 }
18465 return resultobj;
18466 fail:
18467 return NULL;
18468 }
18469
18470
18471 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18472 PyObject *resultobj = 0;
18473 wxEvent *arg1 = (wxEvent *) 0 ;
18474 wxObject *arg2 = (wxObject *) 0 ;
18475 void *argp1 = 0 ;
18476 int res1 = 0 ;
18477 void *argp2 = 0 ;
18478 int res2 = 0 ;
18479 PyObject * obj0 = 0 ;
18480 PyObject * obj1 = 0 ;
18481 char * kwnames[] = {
18482 (char *) "self",(char *) "obj", NULL
18483 };
18484
18485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18487 if (!SWIG_IsOK(res1)) {
18488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18489 }
18490 arg1 = reinterpret_cast< wxEvent * >(argp1);
18491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18492 if (!SWIG_IsOK(res2)) {
18493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18494 }
18495 arg2 = reinterpret_cast< wxObject * >(argp2);
18496 {
18497 PyThreadState* __tstate = wxPyBeginAllowThreads();
18498 (arg1)->SetEventObject(arg2);
18499 wxPyEndAllowThreads(__tstate);
18500 if (PyErr_Occurred()) SWIG_fail;
18501 }
18502 resultobj = SWIG_Py_Void();
18503 return resultobj;
18504 fail:
18505 return NULL;
18506 }
18507
18508
18509 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18510 PyObject *resultobj = 0;
18511 wxEvent *arg1 = (wxEvent *) 0 ;
18512 long result;
18513 void *argp1 = 0 ;
18514 int res1 = 0 ;
18515 PyObject *swig_obj[1] ;
18516
18517 if (!args) SWIG_fail;
18518 swig_obj[0] = args;
18519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18520 if (!SWIG_IsOK(res1)) {
18521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18522 }
18523 arg1 = reinterpret_cast< wxEvent * >(argp1);
18524 {
18525 PyThreadState* __tstate = wxPyBeginAllowThreads();
18526 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18527 wxPyEndAllowThreads(__tstate);
18528 if (PyErr_Occurred()) SWIG_fail;
18529 }
18530 resultobj = SWIG_From_long(static_cast< long >(result));
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj = 0;
18539 wxEvent *arg1 = (wxEvent *) 0 ;
18540 long arg2 = (long) 0 ;
18541 void *argp1 = 0 ;
18542 int res1 = 0 ;
18543 long val2 ;
18544 int ecode2 = 0 ;
18545 PyObject * obj0 = 0 ;
18546 PyObject * obj1 = 0 ;
18547 char * kwnames[] = {
18548 (char *) "self",(char *) "ts", NULL
18549 };
18550
18551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18553 if (!SWIG_IsOK(res1)) {
18554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18555 }
18556 arg1 = reinterpret_cast< wxEvent * >(argp1);
18557 if (obj1) {
18558 ecode2 = SWIG_AsVal_long(obj1, &val2);
18559 if (!SWIG_IsOK(ecode2)) {
18560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18561 }
18562 arg2 = static_cast< long >(val2);
18563 }
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 (arg1)->SetTimestamp(arg2);
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 resultobj = SWIG_Py_Void();
18571 return resultobj;
18572 fail:
18573 return NULL;
18574 }
18575
18576
18577 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18578 PyObject *resultobj = 0;
18579 wxEvent *arg1 = (wxEvent *) 0 ;
18580 int result;
18581 void *argp1 = 0 ;
18582 int res1 = 0 ;
18583 PyObject *swig_obj[1] ;
18584
18585 if (!args) SWIG_fail;
18586 swig_obj[0] = args;
18587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18588 if (!SWIG_IsOK(res1)) {
18589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18590 }
18591 arg1 = reinterpret_cast< wxEvent * >(argp1);
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 result = (int)((wxEvent const *)arg1)->GetId();
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 resultobj = SWIG_From_int(static_cast< int >(result));
18599 return resultobj;
18600 fail:
18601 return NULL;
18602 }
18603
18604
18605 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18606 PyObject *resultobj = 0;
18607 wxEvent *arg1 = (wxEvent *) 0 ;
18608 int arg2 ;
18609 void *argp1 = 0 ;
18610 int res1 = 0 ;
18611 int val2 ;
18612 int ecode2 = 0 ;
18613 PyObject * obj0 = 0 ;
18614 PyObject * obj1 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "Id", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18623 }
18624 arg1 = reinterpret_cast< wxEvent * >(argp1);
18625 ecode2 = SWIG_AsVal_int(obj1, &val2);
18626 if (!SWIG_IsOK(ecode2)) {
18627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18628 }
18629 arg2 = static_cast< int >(val2);
18630 {
18631 PyThreadState* __tstate = wxPyBeginAllowThreads();
18632 (arg1)->SetId(arg2);
18633 wxPyEndAllowThreads(__tstate);
18634 if (PyErr_Occurred()) SWIG_fail;
18635 }
18636 resultobj = SWIG_Py_Void();
18637 return resultobj;
18638 fail:
18639 return NULL;
18640 }
18641
18642
18643 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18644 PyObject *resultobj = 0;
18645 wxEvent *arg1 = (wxEvent *) 0 ;
18646 bool result;
18647 void *argp1 = 0 ;
18648 int res1 = 0 ;
18649 PyObject *swig_obj[1] ;
18650
18651 if (!args) SWIG_fail;
18652 swig_obj[0] = args;
18653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvent * >(argp1);
18658 {
18659 PyThreadState* __tstate = wxPyBeginAllowThreads();
18660 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 {
18665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18666 }
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj = 0;
18675 wxEvent *arg1 = (wxEvent *) 0 ;
18676 bool arg2 = (bool) true ;
18677 void *argp1 = 0 ;
18678 int res1 = 0 ;
18679 bool val2 ;
18680 int ecode2 = 0 ;
18681 PyObject * obj0 = 0 ;
18682 PyObject * obj1 = 0 ;
18683 char * kwnames[] = {
18684 (char *) "self",(char *) "skip", NULL
18685 };
18686
18687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18689 if (!SWIG_IsOK(res1)) {
18690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18691 }
18692 arg1 = reinterpret_cast< wxEvent * >(argp1);
18693 if (obj1) {
18694 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18695 if (!SWIG_IsOK(ecode2)) {
18696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18697 }
18698 arg2 = static_cast< bool >(val2);
18699 }
18700 {
18701 PyThreadState* __tstate = wxPyBeginAllowThreads();
18702 (arg1)->Skip(arg2);
18703 wxPyEndAllowThreads(__tstate);
18704 if (PyErr_Occurred()) SWIG_fail;
18705 }
18706 resultobj = SWIG_Py_Void();
18707 return resultobj;
18708 fail:
18709 return NULL;
18710 }
18711
18712
18713 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18714 PyObject *resultobj = 0;
18715 wxEvent *arg1 = (wxEvent *) 0 ;
18716 bool result;
18717 void *argp1 = 0 ;
18718 int res1 = 0 ;
18719 PyObject *swig_obj[1] ;
18720
18721 if (!args) SWIG_fail;
18722 swig_obj[0] = args;
18723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18724 if (!SWIG_IsOK(res1)) {
18725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18726 }
18727 arg1 = reinterpret_cast< wxEvent * >(argp1);
18728 {
18729 PyThreadState* __tstate = wxPyBeginAllowThreads();
18730 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18731 wxPyEndAllowThreads(__tstate);
18732 if (PyErr_Occurred()) SWIG_fail;
18733 }
18734 {
18735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18736 }
18737 return resultobj;
18738 fail:
18739 return NULL;
18740 }
18741
18742
18743 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18744 PyObject *resultobj = 0;
18745 wxEvent *arg1 = (wxEvent *) 0 ;
18746 bool result;
18747 void *argp1 = 0 ;
18748 int res1 = 0 ;
18749 PyObject *swig_obj[1] ;
18750
18751 if (!args) SWIG_fail;
18752 swig_obj[0] = args;
18753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18754 if (!SWIG_IsOK(res1)) {
18755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18756 }
18757 arg1 = reinterpret_cast< wxEvent * >(argp1);
18758 {
18759 PyThreadState* __tstate = wxPyBeginAllowThreads();
18760 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18761 wxPyEndAllowThreads(__tstate);
18762 if (PyErr_Occurred()) SWIG_fail;
18763 }
18764 {
18765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18766 }
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18774 PyObject *resultobj = 0;
18775 wxEvent *arg1 = (wxEvent *) 0 ;
18776 int result;
18777 void *argp1 = 0 ;
18778 int res1 = 0 ;
18779 PyObject *swig_obj[1] ;
18780
18781 if (!args) SWIG_fail;
18782 swig_obj[0] = args;
18783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18784 if (!SWIG_IsOK(res1)) {
18785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18786 }
18787 arg1 = reinterpret_cast< wxEvent * >(argp1);
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (int)(arg1)->StopPropagation();
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_From_int(static_cast< int >(result));
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18802 PyObject *resultobj = 0;
18803 wxEvent *arg1 = (wxEvent *) 0 ;
18804 int arg2 ;
18805 void *argp1 = 0 ;
18806 int res1 = 0 ;
18807 int val2 ;
18808 int ecode2 = 0 ;
18809 PyObject * obj0 = 0 ;
18810 PyObject * obj1 = 0 ;
18811 char * kwnames[] = {
18812 (char *) "self",(char *) "propagationLevel", NULL
18813 };
18814
18815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18817 if (!SWIG_IsOK(res1)) {
18818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18819 }
18820 arg1 = reinterpret_cast< wxEvent * >(argp1);
18821 ecode2 = SWIG_AsVal_int(obj1, &val2);
18822 if (!SWIG_IsOK(ecode2)) {
18823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18824 }
18825 arg2 = static_cast< int >(val2);
18826 {
18827 PyThreadState* __tstate = wxPyBeginAllowThreads();
18828 (arg1)->ResumePropagation(arg2);
18829 wxPyEndAllowThreads(__tstate);
18830 if (PyErr_Occurred()) SWIG_fail;
18831 }
18832 resultobj = SWIG_Py_Void();
18833 return resultobj;
18834 fail:
18835 return NULL;
18836 }
18837
18838
18839 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18840 PyObject *resultobj = 0;
18841 wxEvent *arg1 = (wxEvent *) 0 ;
18842 wxEvent *result = 0 ;
18843 void *argp1 = 0 ;
18844 int res1 = 0 ;
18845 PyObject *swig_obj[1] ;
18846
18847 if (!args) SWIG_fail;
18848 swig_obj[0] = args;
18849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18850 if (!SWIG_IsOK(res1)) {
18851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18852 }
18853 arg1 = reinterpret_cast< wxEvent * >(argp1);
18854 {
18855 PyThreadState* __tstate = wxPyBeginAllowThreads();
18856 result = (wxEvent *)(arg1)->Clone();
18857 wxPyEndAllowThreads(__tstate);
18858 if (PyErr_Occurred()) SWIG_fail;
18859 }
18860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18861 return resultobj;
18862 fail:
18863 return NULL;
18864 }
18865
18866
18867 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18868 PyObject *obj;
18869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18870 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18871 return SWIG_Py_Void();
18872 }
18873
18874 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18875 PyObject *resultobj = 0;
18876 wxEvent *arg1 = 0 ;
18877 wxPropagationDisabler *result = 0 ;
18878 void *argp1 = 0 ;
18879 int res1 = 0 ;
18880 PyObject * obj0 = 0 ;
18881 char * kwnames[] = {
18882 (char *) "event", NULL
18883 };
18884
18885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18886 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18887 if (!SWIG_IsOK(res1)) {
18888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18889 }
18890 if (!argp1) {
18891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18892 }
18893 arg1 = reinterpret_cast< wxEvent * >(argp1);
18894 {
18895 PyThreadState* __tstate = wxPyBeginAllowThreads();
18896 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18908 PyObject *resultobj = 0;
18909 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18910 void *argp1 = 0 ;
18911 int res1 = 0 ;
18912 PyObject *swig_obj[1] ;
18913
18914 if (!args) SWIG_fail;
18915 swig_obj[0] = args;
18916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18917 if (!SWIG_IsOK(res1)) {
18918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18919 }
18920 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 delete arg1;
18924
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_Py_Void();
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18936 PyObject *obj;
18937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18938 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18939 return SWIG_Py_Void();
18940 }
18941
18942 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18943 return SWIG_Python_InitShadowInstance(args);
18944 }
18945
18946 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18947 PyObject *resultobj = 0;
18948 wxEvent *arg1 = 0 ;
18949 wxPropagateOnce *result = 0 ;
18950 void *argp1 = 0 ;
18951 int res1 = 0 ;
18952 PyObject * obj0 = 0 ;
18953 char * kwnames[] = {
18954 (char *) "event", NULL
18955 };
18956
18957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18958 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18959 if (!SWIG_IsOK(res1)) {
18960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18961 }
18962 if (!argp1) {
18963 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18964 }
18965 arg1 = reinterpret_cast< wxEvent * >(argp1);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18980 PyObject *resultobj = 0;
18981 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18982 void *argp1 = 0 ;
18983 int res1 = 0 ;
18984 PyObject *swig_obj[1] ;
18985
18986 if (!args) SWIG_fail;
18987 swig_obj[0] = args;
18988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18989 if (!SWIG_IsOK(res1)) {
18990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18991 }
18992 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 delete arg1;
18996
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_Py_Void();
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 PyObject *obj;
19009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19010 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19011 return SWIG_Py_Void();
19012 }
19013
19014 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19015 return SWIG_Python_InitShadowInstance(args);
19016 }
19017
19018 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj = 0;
19020 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19021 int arg2 = (int) 0 ;
19022 wxCommandEvent *result = 0 ;
19023 int val1 ;
19024 int ecode1 = 0 ;
19025 int val2 ;
19026 int ecode2 = 0 ;
19027 PyObject * obj0 = 0 ;
19028 PyObject * obj1 = 0 ;
19029 char * kwnames[] = {
19030 (char *) "commandType",(char *) "winid", NULL
19031 };
19032
19033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19034 if (obj0) {
19035 ecode1 = SWIG_AsVal_int(obj0, &val1);
19036 if (!SWIG_IsOK(ecode1)) {
19037 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19038 }
19039 arg1 = static_cast< wxEventType >(val1);
19040 }
19041 if (obj1) {
19042 ecode2 = SWIG_AsVal_int(obj1, &val2);
19043 if (!SWIG_IsOK(ecode2)) {
19044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19045 }
19046 arg2 = static_cast< int >(val2);
19047 }
19048 {
19049 PyThreadState* __tstate = wxPyBeginAllowThreads();
19050 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19051 wxPyEndAllowThreads(__tstate);
19052 if (PyErr_Occurred()) SWIG_fail;
19053 }
19054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19062 PyObject *resultobj = 0;
19063 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19064 int result;
19065 void *argp1 = 0 ;
19066 int res1 = 0 ;
19067 PyObject *swig_obj[1] ;
19068
19069 if (!args) SWIG_fail;
19070 swig_obj[0] = args;
19071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19072 if (!SWIG_IsOK(res1)) {
19073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19074 }
19075 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_From_int(static_cast< int >(result));
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19090 PyObject *resultobj = 0;
19091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19092 wxString *arg2 = 0 ;
19093 void *argp1 = 0 ;
19094 int res1 = 0 ;
19095 bool temp2 = false ;
19096 PyObject * obj0 = 0 ;
19097 PyObject * obj1 = 0 ;
19098 char * kwnames[] = {
19099 (char *) "self",(char *) "s", NULL
19100 };
19101
19102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19106 }
19107 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19108 {
19109 arg2 = wxString_in_helper(obj1);
19110 if (arg2 == NULL) SWIG_fail;
19111 temp2 = true;
19112 }
19113 {
19114 PyThreadState* __tstate = wxPyBeginAllowThreads();
19115 (arg1)->SetString((wxString const &)*arg2);
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 resultobj = SWIG_Py_Void();
19120 {
19121 if (temp2)
19122 delete arg2;
19123 }
19124 return resultobj;
19125 fail:
19126 {
19127 if (temp2)
19128 delete arg2;
19129 }
19130 return NULL;
19131 }
19132
19133
19134 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19135 PyObject *resultobj = 0;
19136 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19137 wxString result;
19138 void *argp1 = 0 ;
19139 int res1 = 0 ;
19140 PyObject *swig_obj[1] ;
19141
19142 if (!args) SWIG_fail;
19143 swig_obj[0] = args;
19144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19145 if (!SWIG_IsOK(res1)) {
19146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19147 }
19148 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = ((wxCommandEvent const *)arg1)->GetString();
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 {
19156 #if wxUSE_UNICODE
19157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19158 #else
19159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19160 #endif
19161 }
19162 return resultobj;
19163 fail:
19164 return NULL;
19165 }
19166
19167
19168 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19169 PyObject *resultobj = 0;
19170 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19171 bool result;
19172 void *argp1 = 0 ;
19173 int res1 = 0 ;
19174 PyObject *swig_obj[1] ;
19175
19176 if (!args) SWIG_fail;
19177 swig_obj[0] = args;
19178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19181 }
19182 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 {
19190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19191 }
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19199 PyObject *resultobj = 0;
19200 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19201 bool result;
19202 void *argp1 = 0 ;
19203 int res1 = 0 ;
19204 PyObject *swig_obj[1] ;
19205
19206 if (!args) SWIG_fail;
19207 swig_obj[0] = args;
19208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19209 if (!SWIG_IsOK(res1)) {
19210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19211 }
19212 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19213 {
19214 PyThreadState* __tstate = wxPyBeginAllowThreads();
19215 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19216 wxPyEndAllowThreads(__tstate);
19217 if (PyErr_Occurred()) SWIG_fail;
19218 }
19219 {
19220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19221 }
19222 return resultobj;
19223 fail:
19224 return NULL;
19225 }
19226
19227
19228 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj = 0;
19230 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19231 long arg2 ;
19232 void *argp1 = 0 ;
19233 int res1 = 0 ;
19234 long val2 ;
19235 int ecode2 = 0 ;
19236 PyObject * obj0 = 0 ;
19237 PyObject * obj1 = 0 ;
19238 char * kwnames[] = {
19239 (char *) "self",(char *) "extraLong", NULL
19240 };
19241
19242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19244 if (!SWIG_IsOK(res1)) {
19245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19246 }
19247 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19248 ecode2 = SWIG_AsVal_long(obj1, &val2);
19249 if (!SWIG_IsOK(ecode2)) {
19250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19251 }
19252 arg2 = static_cast< long >(val2);
19253 {
19254 PyThreadState* __tstate = wxPyBeginAllowThreads();
19255 (arg1)->SetExtraLong(arg2);
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 resultobj = SWIG_Py_Void();
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19267 PyObject *resultobj = 0;
19268 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19269 long result;
19270 void *argp1 = 0 ;
19271 int res1 = 0 ;
19272 PyObject *swig_obj[1] ;
19273
19274 if (!args) SWIG_fail;
19275 swig_obj[0] = args;
19276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19277 if (!SWIG_IsOK(res1)) {
19278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19279 }
19280 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 resultobj = SWIG_From_long(static_cast< long >(result));
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = 0;
19296 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19297 int arg2 ;
19298 void *argp1 = 0 ;
19299 int res1 = 0 ;
19300 int val2 ;
19301 int ecode2 = 0 ;
19302 PyObject * obj0 = 0 ;
19303 PyObject * obj1 = 0 ;
19304 char * kwnames[] = {
19305 (char *) "self",(char *) "i", NULL
19306 };
19307
19308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19310 if (!SWIG_IsOK(res1)) {
19311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19312 }
19313 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19314 ecode2 = SWIG_AsVal_int(obj1, &val2);
19315 if (!SWIG_IsOK(ecode2)) {
19316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19317 }
19318 arg2 = static_cast< int >(val2);
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 (arg1)->SetInt(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_Py_Void();
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19333 PyObject *resultobj = 0;
19334 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19335 int result;
19336 void *argp1 = 0 ;
19337 int res1 = 0 ;
19338 PyObject *swig_obj[1] ;
19339
19340 if (!args) SWIG_fail;
19341 swig_obj[0] = args;
19342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19343 if (!SWIG_IsOK(res1)) {
19344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19345 }
19346 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19347 {
19348 PyThreadState* __tstate = wxPyBeginAllowThreads();
19349 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 resultobj = SWIG_From_int(static_cast< int >(result));
19354 return resultobj;
19355 fail:
19356 return NULL;
19357 }
19358
19359
19360 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19361 PyObject *resultobj = 0;
19362 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19363 PyObject *result = 0 ;
19364 void *argp1 = 0 ;
19365 int res1 = 0 ;
19366 PyObject *swig_obj[1] ;
19367
19368 if (!args) SWIG_fail;
19369 swig_obj[0] = args;
19370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19371 if (!SWIG_IsOK(res1)) {
19372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19373 }
19374 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19375 {
19376 PyThreadState* __tstate = wxPyBeginAllowThreads();
19377 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19378 wxPyEndAllowThreads(__tstate);
19379 if (PyErr_Occurred()) SWIG_fail;
19380 }
19381 resultobj = result;
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj = 0;
19390 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19391 PyObject *arg2 = (PyObject *) 0 ;
19392 void *argp1 = 0 ;
19393 int res1 = 0 ;
19394 PyObject * obj0 = 0 ;
19395 PyObject * obj1 = 0 ;
19396 char * kwnames[] = {
19397 (char *) "self",(char *) "clientData", NULL
19398 };
19399
19400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19404 }
19405 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19406 arg2 = obj1;
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 wxCommandEvent_SetClientData(arg1,arg2);
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 resultobj = SWIG_Py_Void();
19414 return resultobj;
19415 fail:
19416 return NULL;
19417 }
19418
19419
19420 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19421 PyObject *resultobj = 0;
19422 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19423 wxEvent *result = 0 ;
19424 void *argp1 = 0 ;
19425 int res1 = 0 ;
19426 PyObject *swig_obj[1] ;
19427
19428 if (!args) SWIG_fail;
19429 swig_obj[0] = args;
19430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19431 if (!SWIG_IsOK(res1)) {
19432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19433 }
19434 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19435 {
19436 PyThreadState* __tstate = wxPyBeginAllowThreads();
19437 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19438 wxPyEndAllowThreads(__tstate);
19439 if (PyErr_Occurred()) SWIG_fail;
19440 }
19441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19442 return resultobj;
19443 fail:
19444 return NULL;
19445 }
19446
19447
19448 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 PyObject *obj;
19450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19451 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19452 return SWIG_Py_Void();
19453 }
19454
19455 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19456 return SWIG_Python_InitShadowInstance(args);
19457 }
19458
19459 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19460 PyObject *resultobj = 0;
19461 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19462 int arg2 = (int) 0 ;
19463 wxNotifyEvent *result = 0 ;
19464 int val1 ;
19465 int ecode1 = 0 ;
19466 int val2 ;
19467 int ecode2 = 0 ;
19468 PyObject * obj0 = 0 ;
19469 PyObject * obj1 = 0 ;
19470 char * kwnames[] = {
19471 (char *) "commandType",(char *) "winid", NULL
19472 };
19473
19474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19475 if (obj0) {
19476 ecode1 = SWIG_AsVal_int(obj0, &val1);
19477 if (!SWIG_IsOK(ecode1)) {
19478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19479 }
19480 arg1 = static_cast< wxEventType >(val1);
19481 }
19482 if (obj1) {
19483 ecode2 = SWIG_AsVal_int(obj1, &val2);
19484 if (!SWIG_IsOK(ecode2)) {
19485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19486 }
19487 arg2 = static_cast< int >(val2);
19488 }
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *resultobj = 0;
19504 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19505 void *argp1 = 0 ;
19506 int res1 = 0 ;
19507 PyObject *swig_obj[1] ;
19508
19509 if (!args) SWIG_fail;
19510 swig_obj[0] = args;
19511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19512 if (!SWIG_IsOK(res1)) {
19513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19514 }
19515 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19516 {
19517 PyThreadState* __tstate = wxPyBeginAllowThreads();
19518 (arg1)->Veto();
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 resultobj = SWIG_Py_Void();
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19530 PyObject *resultobj = 0;
19531 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19532 void *argp1 = 0 ;
19533 int res1 = 0 ;
19534 PyObject *swig_obj[1] ;
19535
19536 if (!args) SWIG_fail;
19537 swig_obj[0] = args;
19538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19539 if (!SWIG_IsOK(res1)) {
19540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19541 }
19542 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 (arg1)->Allow();
19546 wxPyEndAllowThreads(__tstate);
19547 if (PyErr_Occurred()) SWIG_fail;
19548 }
19549 resultobj = SWIG_Py_Void();
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19557 PyObject *resultobj = 0;
19558 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19559 bool result;
19560 void *argp1 = 0 ;
19561 int res1 = 0 ;
19562 PyObject *swig_obj[1] ;
19563
19564 if (!args) SWIG_fail;
19565 swig_obj[0] = args;
19566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19567 if (!SWIG_IsOK(res1)) {
19568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19569 }
19570 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (bool)(arg1)->IsAllowed();
19574 wxPyEndAllowThreads(__tstate);
19575 if (PyErr_Occurred()) SWIG_fail;
19576 }
19577 {
19578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19579 }
19580 return resultobj;
19581 fail:
19582 return NULL;
19583 }
19584
19585
19586 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19587 PyObject *obj;
19588 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19589 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19590 return SWIG_Py_Void();
19591 }
19592
19593 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19594 return SWIG_Python_InitShadowInstance(args);
19595 }
19596
19597 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19598 PyObject *resultobj = 0;
19599 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19600 int arg2 = (int) 0 ;
19601 int arg3 = (int) 0 ;
19602 int arg4 = (int) 0 ;
19603 wxScrollEvent *result = 0 ;
19604 int val1 ;
19605 int ecode1 = 0 ;
19606 int val2 ;
19607 int ecode2 = 0 ;
19608 int val3 ;
19609 int ecode3 = 0 ;
19610 int val4 ;
19611 int ecode4 = 0 ;
19612 PyObject * obj0 = 0 ;
19613 PyObject * obj1 = 0 ;
19614 PyObject * obj2 = 0 ;
19615 PyObject * obj3 = 0 ;
19616 char * kwnames[] = {
19617 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19618 };
19619
19620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19621 if (obj0) {
19622 ecode1 = SWIG_AsVal_int(obj0, &val1);
19623 if (!SWIG_IsOK(ecode1)) {
19624 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19625 }
19626 arg1 = static_cast< wxEventType >(val1);
19627 }
19628 if (obj1) {
19629 ecode2 = SWIG_AsVal_int(obj1, &val2);
19630 if (!SWIG_IsOK(ecode2)) {
19631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19632 }
19633 arg2 = static_cast< int >(val2);
19634 }
19635 if (obj2) {
19636 ecode3 = SWIG_AsVal_int(obj2, &val3);
19637 if (!SWIG_IsOK(ecode3)) {
19638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19639 }
19640 arg3 = static_cast< int >(val3);
19641 }
19642 if (obj3) {
19643 ecode4 = SWIG_AsVal_int(obj3, &val4);
19644 if (!SWIG_IsOK(ecode4)) {
19645 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19646 }
19647 arg4 = static_cast< int >(val4);
19648 }
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19652 wxPyEndAllowThreads(__tstate);
19653 if (PyErr_Occurred()) SWIG_fail;
19654 }
19655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19663 PyObject *resultobj = 0;
19664 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19665 int result;
19666 void *argp1 = 0 ;
19667 int res1 = 0 ;
19668 PyObject *swig_obj[1] ;
19669
19670 if (!args) SWIG_fail;
19671 swig_obj[0] = args;
19672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19673 if (!SWIG_IsOK(res1)) {
19674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19675 }
19676 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19677 {
19678 PyThreadState* __tstate = wxPyBeginAllowThreads();
19679 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19680 wxPyEndAllowThreads(__tstate);
19681 if (PyErr_Occurred()) SWIG_fail;
19682 }
19683 resultobj = SWIG_From_int(static_cast< int >(result));
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19691 PyObject *resultobj = 0;
19692 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19693 int result;
19694 void *argp1 = 0 ;
19695 int res1 = 0 ;
19696 PyObject *swig_obj[1] ;
19697
19698 if (!args) SWIG_fail;
19699 swig_obj[0] = args;
19700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19701 if (!SWIG_IsOK(res1)) {
19702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19703 }
19704 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19708 wxPyEndAllowThreads(__tstate);
19709 if (PyErr_Occurred()) SWIG_fail;
19710 }
19711 resultobj = SWIG_From_int(static_cast< int >(result));
19712 return resultobj;
19713 fail:
19714 return NULL;
19715 }
19716
19717
19718 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19719 PyObject *resultobj = 0;
19720 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19721 int arg2 ;
19722 void *argp1 = 0 ;
19723 int res1 = 0 ;
19724 int val2 ;
19725 int ecode2 = 0 ;
19726 PyObject * obj0 = 0 ;
19727 PyObject * obj1 = 0 ;
19728 char * kwnames[] = {
19729 (char *) "self",(char *) "orient", NULL
19730 };
19731
19732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19736 }
19737 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19738 ecode2 = SWIG_AsVal_int(obj1, &val2);
19739 if (!SWIG_IsOK(ecode2)) {
19740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19741 }
19742 arg2 = static_cast< int >(val2);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 (arg1)->SetOrientation(arg2);
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_Py_Void();
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19759 int arg2 ;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 int val2 ;
19763 int ecode2 = 0 ;
19764 PyObject * obj0 = 0 ;
19765 PyObject * obj1 = 0 ;
19766 char * kwnames[] = {
19767 (char *) "self",(char *) "pos", NULL
19768 };
19769
19770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19772 if (!SWIG_IsOK(res1)) {
19773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19774 }
19775 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19776 ecode2 = SWIG_AsVal_int(obj1, &val2);
19777 if (!SWIG_IsOK(ecode2)) {
19778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19779 }
19780 arg2 = static_cast< int >(val2);
19781 {
19782 PyThreadState* __tstate = wxPyBeginAllowThreads();
19783 (arg1)->SetPosition(arg2);
19784 wxPyEndAllowThreads(__tstate);
19785 if (PyErr_Occurred()) SWIG_fail;
19786 }
19787 resultobj = SWIG_Py_Void();
19788 return resultobj;
19789 fail:
19790 return NULL;
19791 }
19792
19793
19794 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19795 PyObject *obj;
19796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19797 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19798 return SWIG_Py_Void();
19799 }
19800
19801 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19802 return SWIG_Python_InitShadowInstance(args);
19803 }
19804
19805 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19806 PyObject *resultobj = 0;
19807 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19808 int arg2 = (int) 0 ;
19809 int arg3 = (int) 0 ;
19810 wxScrollWinEvent *result = 0 ;
19811 int val1 ;
19812 int ecode1 = 0 ;
19813 int val2 ;
19814 int ecode2 = 0 ;
19815 int val3 ;
19816 int ecode3 = 0 ;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 PyObject * obj2 = 0 ;
19820 char * kwnames[] = {
19821 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19822 };
19823
19824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19825 if (obj0) {
19826 ecode1 = SWIG_AsVal_int(obj0, &val1);
19827 if (!SWIG_IsOK(ecode1)) {
19828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19829 }
19830 arg1 = static_cast< wxEventType >(val1);
19831 }
19832 if (obj1) {
19833 ecode2 = SWIG_AsVal_int(obj1, &val2);
19834 if (!SWIG_IsOK(ecode2)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19836 }
19837 arg2 = static_cast< int >(val2);
19838 }
19839 if (obj2) {
19840 ecode3 = SWIG_AsVal_int(obj2, &val3);
19841 if (!SWIG_IsOK(ecode3)) {
19842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19843 }
19844 arg3 = static_cast< int >(val3);
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19860 PyObject *resultobj = 0;
19861 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19862 int result;
19863 void *argp1 = 0 ;
19864 int res1 = 0 ;
19865 PyObject *swig_obj[1] ;
19866
19867 if (!args) SWIG_fail;
19868 swig_obj[0] = args;
19869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19870 if (!SWIG_IsOK(res1)) {
19871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19872 }
19873 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19874 {
19875 PyThreadState* __tstate = wxPyBeginAllowThreads();
19876 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19877 wxPyEndAllowThreads(__tstate);
19878 if (PyErr_Occurred()) SWIG_fail;
19879 }
19880 resultobj = SWIG_From_int(static_cast< int >(result));
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19888 PyObject *resultobj = 0;
19889 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19890 int result;
19891 void *argp1 = 0 ;
19892 int res1 = 0 ;
19893 PyObject *swig_obj[1] ;
19894
19895 if (!args) SWIG_fail;
19896 swig_obj[0] = args;
19897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19898 if (!SWIG_IsOK(res1)) {
19899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19900 }
19901 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19902 {
19903 PyThreadState* __tstate = wxPyBeginAllowThreads();
19904 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19905 wxPyEndAllowThreads(__tstate);
19906 if (PyErr_Occurred()) SWIG_fail;
19907 }
19908 resultobj = SWIG_From_int(static_cast< int >(result));
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj = 0;
19917 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19918 int arg2 ;
19919 void *argp1 = 0 ;
19920 int res1 = 0 ;
19921 int val2 ;
19922 int ecode2 = 0 ;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 char * kwnames[] = {
19926 (char *) "self",(char *) "orient", NULL
19927 };
19928
19929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19931 if (!SWIG_IsOK(res1)) {
19932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19933 }
19934 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19935 ecode2 = SWIG_AsVal_int(obj1, &val2);
19936 if (!SWIG_IsOK(ecode2)) {
19937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19938 }
19939 arg2 = static_cast< int >(val2);
19940 {
19941 PyThreadState* __tstate = wxPyBeginAllowThreads();
19942 (arg1)->SetOrientation(arg2);
19943 wxPyEndAllowThreads(__tstate);
19944 if (PyErr_Occurred()) SWIG_fail;
19945 }
19946 resultobj = SWIG_Py_Void();
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj = 0;
19955 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19956 int arg2 ;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 int val2 ;
19960 int ecode2 = 0 ;
19961 PyObject * obj0 = 0 ;
19962 PyObject * obj1 = 0 ;
19963 char * kwnames[] = {
19964 (char *) "self",(char *) "pos", NULL
19965 };
19966
19967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19969 if (!SWIG_IsOK(res1)) {
19970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19971 }
19972 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19973 ecode2 = SWIG_AsVal_int(obj1, &val2);
19974 if (!SWIG_IsOK(ecode2)) {
19975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19976 }
19977 arg2 = static_cast< int >(val2);
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 (arg1)->SetPosition(arg2);
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 resultobj = SWIG_Py_Void();
19985 return resultobj;
19986 fail:
19987 return NULL;
19988 }
19989
19990
19991 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19992 PyObject *obj;
19993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19994 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19995 return SWIG_Py_Void();
19996 }
19997
19998 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19999 return SWIG_Python_InitShadowInstance(args);
20000 }
20001
20002 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20003 PyObject *resultobj = 0;
20004 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20005 wxMouseEvent *result = 0 ;
20006 int val1 ;
20007 int ecode1 = 0 ;
20008 PyObject * obj0 = 0 ;
20009 char * kwnames[] = {
20010 (char *) "mouseType", NULL
20011 };
20012
20013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20014 if (obj0) {
20015 ecode1 = SWIG_AsVal_int(obj0, &val1);
20016 if (!SWIG_IsOK(ecode1)) {
20017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20018 }
20019 arg1 = static_cast< wxEventType >(val1);
20020 }
20021 {
20022 PyThreadState* __tstate = wxPyBeginAllowThreads();
20023 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20024 wxPyEndAllowThreads(__tstate);
20025 if (PyErr_Occurred()) SWIG_fail;
20026 }
20027 {
20028 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20029 }
20030 return resultobj;
20031 fail:
20032 return NULL;
20033 }
20034
20035
20036 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20037 PyObject *resultobj = 0;
20038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20039 bool result;
20040 void *argp1 = 0 ;
20041 int res1 = 0 ;
20042 PyObject *swig_obj[1] ;
20043
20044 if (!args) SWIG_fail;
20045 swig_obj[0] = args;
20046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20047 if (!SWIG_IsOK(res1)) {
20048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20049 }
20050 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20051 {
20052 PyThreadState* __tstate = wxPyBeginAllowThreads();
20053 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 {
20058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20059 }
20060 return resultobj;
20061 fail:
20062 return NULL;
20063 }
20064
20065
20066 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj = 0;
20068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20069 int arg2 = (int) wxMOUSE_BTN_ANY ;
20070 bool result;
20071 void *argp1 = 0 ;
20072 int res1 = 0 ;
20073 int val2 ;
20074 int ecode2 = 0 ;
20075 PyObject * obj0 = 0 ;
20076 PyObject * obj1 = 0 ;
20077 char * kwnames[] = {
20078 (char *) "self",(char *) "but", NULL
20079 };
20080
20081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20083 if (!SWIG_IsOK(res1)) {
20084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20085 }
20086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20087 if (obj1) {
20088 ecode2 = SWIG_AsVal_int(obj1, &val2);
20089 if (!SWIG_IsOK(ecode2)) {
20090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20091 }
20092 arg2 = static_cast< int >(val2);
20093 }
20094 {
20095 PyThreadState* __tstate = wxPyBeginAllowThreads();
20096 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 {
20101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20102 }
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj = 0;
20111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20112 int arg2 = (int) wxMOUSE_BTN_ANY ;
20113 bool result;
20114 void *argp1 = 0 ;
20115 int res1 = 0 ;
20116 int val2 ;
20117 int ecode2 = 0 ;
20118 PyObject * obj0 = 0 ;
20119 PyObject * obj1 = 0 ;
20120 char * kwnames[] = {
20121 (char *) "self",(char *) "but", NULL
20122 };
20123
20124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20126 if (!SWIG_IsOK(res1)) {
20127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20128 }
20129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20130 if (obj1) {
20131 ecode2 = SWIG_AsVal_int(obj1, &val2);
20132 if (!SWIG_IsOK(ecode2)) {
20133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20134 }
20135 arg2 = static_cast< int >(val2);
20136 }
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20145 }
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20153 PyObject *resultobj = 0;
20154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20155 int arg2 = (int) wxMOUSE_BTN_ANY ;
20156 bool result;
20157 void *argp1 = 0 ;
20158 int res1 = 0 ;
20159 int val2 ;
20160 int ecode2 = 0 ;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 char * kwnames[] = {
20164 (char *) "self",(char *) "but", NULL
20165 };
20166
20167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20169 if (!SWIG_IsOK(res1)) {
20170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20171 }
20172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20173 if (obj1) {
20174 ecode2 = SWIG_AsVal_int(obj1, &val2);
20175 if (!SWIG_IsOK(ecode2)) {
20176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20177 }
20178 arg2 = static_cast< int >(val2);
20179 }
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 {
20187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20188 }
20189 return resultobj;
20190 fail:
20191 return NULL;
20192 }
20193
20194
20195 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj = 0;
20197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20198 int arg2 ;
20199 bool result;
20200 void *argp1 = 0 ;
20201 int res1 = 0 ;
20202 int val2 ;
20203 int ecode2 = 0 ;
20204 PyObject * obj0 = 0 ;
20205 PyObject * obj1 = 0 ;
20206 char * kwnames[] = {
20207 (char *) "self",(char *) "button", NULL
20208 };
20209
20210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20212 if (!SWIG_IsOK(res1)) {
20213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20214 }
20215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20216 ecode2 = SWIG_AsVal_int(obj1, &val2);
20217 if (!SWIG_IsOK(ecode2)) {
20218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20219 }
20220 arg2 = static_cast< int >(val2);
20221 {
20222 PyThreadState* __tstate = wxPyBeginAllowThreads();
20223 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20224 wxPyEndAllowThreads(__tstate);
20225 if (PyErr_Occurred()) SWIG_fail;
20226 }
20227 {
20228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20229 }
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20237 PyObject *resultobj = 0;
20238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20239 int arg2 ;
20240 bool result;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 int val2 ;
20244 int ecode2 = 0 ;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char * kwnames[] = {
20248 (char *) "self",(char *) "but", NULL
20249 };
20250
20251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20255 }
20256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20257 ecode2 = SWIG_AsVal_int(obj1, &val2);
20258 if (!SWIG_IsOK(ecode2)) {
20259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20260 }
20261 arg2 = static_cast< int >(val2);
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 {
20269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20270 }
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20278 PyObject *resultobj = 0;
20279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20280 int result;
20281 void *argp1 = 0 ;
20282 int res1 = 0 ;
20283 PyObject *swig_obj[1] ;
20284
20285 if (!args) SWIG_fail;
20286 swig_obj[0] = args;
20287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20288 if (!SWIG_IsOK(res1)) {
20289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20290 }
20291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_From_int(static_cast< int >(result));
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *resultobj = 0;
20307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20308 bool result;
20309 void *argp1 = 0 ;
20310 int res1 = 0 ;
20311 PyObject *swig_obj[1] ;
20312
20313 if (!args) SWIG_fail;
20314 swig_obj[0] = args;
20315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20316 if (!SWIG_IsOK(res1)) {
20317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20318 }
20319 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20320 {
20321 PyThreadState* __tstate = wxPyBeginAllowThreads();
20322 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 {
20327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20328 }
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20336 PyObject *resultobj = 0;
20337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20338 bool result;
20339 void *argp1 = 0 ;
20340 int res1 = 0 ;
20341 PyObject *swig_obj[1] ;
20342
20343 if (!args) SWIG_fail;
20344 swig_obj[0] = args;
20345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20346 if (!SWIG_IsOK(res1)) {
20347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20348 }
20349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20358 }
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20366 PyObject *resultobj = 0;
20367 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20368 bool result;
20369 void *argp1 = 0 ;
20370 int res1 = 0 ;
20371 PyObject *swig_obj[1] ;
20372
20373 if (!args) SWIG_fail;
20374 swig_obj[0] = args;
20375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20376 if (!SWIG_IsOK(res1)) {
20377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20378 }
20379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20388 }
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20396 PyObject *resultobj = 0;
20397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20398 bool result;
20399 void *argp1 = 0 ;
20400 int res1 = 0 ;
20401 PyObject *swig_obj[1] ;
20402
20403 if (!args) SWIG_fail;
20404 swig_obj[0] = args;
20405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20406 if (!SWIG_IsOK(res1)) {
20407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20408 }
20409 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20410 {
20411 PyThreadState* __tstate = wxPyBeginAllowThreads();
20412 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 {
20417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20426 PyObject *resultobj = 0;
20427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20428 bool result;
20429 void *argp1 = 0 ;
20430 int res1 = 0 ;
20431 PyObject *swig_obj[1] ;
20432
20433 if (!args) SWIG_fail;
20434 swig_obj[0] = args;
20435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20436 if (!SWIG_IsOK(res1)) {
20437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20438 }
20439 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20440 {
20441 PyThreadState* __tstate = wxPyBeginAllowThreads();
20442 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 {
20447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20448 }
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20456 PyObject *resultobj = 0;
20457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20458 bool result;
20459 void *argp1 = 0 ;
20460 int res1 = 0 ;
20461 PyObject *swig_obj[1] ;
20462
20463 if (!args) SWIG_fail;
20464 swig_obj[0] = args;
20465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20466 if (!SWIG_IsOK(res1)) {
20467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20468 }
20469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20470 {
20471 PyThreadState* __tstate = wxPyBeginAllowThreads();
20472 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 {
20477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20478 }
20479 return resultobj;
20480 fail:
20481 return NULL;
20482 }
20483
20484
20485 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20486 PyObject *resultobj = 0;
20487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20488 bool result;
20489 void *argp1 = 0 ;
20490 int res1 = 0 ;
20491 PyObject *swig_obj[1] ;
20492
20493 if (!args) SWIG_fail;
20494 swig_obj[0] = args;
20495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20496 if (!SWIG_IsOK(res1)) {
20497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20498 }
20499 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20500 {
20501 PyThreadState* __tstate = wxPyBeginAllowThreads();
20502 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20503 wxPyEndAllowThreads(__tstate);
20504 if (PyErr_Occurred()) SWIG_fail;
20505 }
20506 {
20507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20508 }
20509 return resultobj;
20510 fail:
20511 return NULL;
20512 }
20513
20514
20515 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20516 PyObject *resultobj = 0;
20517 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20518 bool result;
20519 void *argp1 = 0 ;
20520 int res1 = 0 ;
20521 PyObject *swig_obj[1] ;
20522
20523 if (!args) SWIG_fail;
20524 swig_obj[0] = args;
20525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20526 if (!SWIG_IsOK(res1)) {
20527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20528 }
20529 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20530 {
20531 PyThreadState* __tstate = wxPyBeginAllowThreads();
20532 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20533 wxPyEndAllowThreads(__tstate);
20534 if (PyErr_Occurred()) SWIG_fail;
20535 }
20536 {
20537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20546 PyObject *resultobj = 0;
20547 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20548 bool result;
20549 void *argp1 = 0 ;
20550 int res1 = 0 ;
20551 PyObject *swig_obj[1] ;
20552
20553 if (!args) SWIG_fail;
20554 swig_obj[0] = args;
20555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20556 if (!SWIG_IsOK(res1)) {
20557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20558 }
20559 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20560 {
20561 PyThreadState* __tstate = wxPyBeginAllowThreads();
20562 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20563 wxPyEndAllowThreads(__tstate);
20564 if (PyErr_Occurred()) SWIG_fail;
20565 }
20566 {
20567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20568 }
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20576 PyObject *resultobj = 0;
20577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20578 bool result;
20579 void *argp1 = 0 ;
20580 int res1 = 0 ;
20581 PyObject *swig_obj[1] ;
20582
20583 if (!args) SWIG_fail;
20584 swig_obj[0] = args;
20585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20586 if (!SWIG_IsOK(res1)) {
20587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20588 }
20589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20593 wxPyEndAllowThreads(__tstate);
20594 if (PyErr_Occurred()) SWIG_fail;
20595 }
20596 {
20597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20598 }
20599 return resultobj;
20600 fail:
20601 return NULL;
20602 }
20603
20604
20605 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20606 PyObject *resultobj = 0;
20607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20608 bool result;
20609 void *argp1 = 0 ;
20610 int res1 = 0 ;
20611 PyObject *swig_obj[1] ;
20612
20613 if (!args) SWIG_fail;
20614 swig_obj[0] = args;
20615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20616 if (!SWIG_IsOK(res1)) {
20617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20618 }
20619 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20620 {
20621 PyThreadState* __tstate = wxPyBeginAllowThreads();
20622 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20623 wxPyEndAllowThreads(__tstate);
20624 if (PyErr_Occurred()) SWIG_fail;
20625 }
20626 {
20627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20628 }
20629 return resultobj;
20630 fail:
20631 return NULL;
20632 }
20633
20634
20635 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20636 PyObject *resultobj = 0;
20637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20638 bool result;
20639 void *argp1 = 0 ;
20640 int res1 = 0 ;
20641 PyObject *swig_obj[1] ;
20642
20643 if (!args) SWIG_fail;
20644 swig_obj[0] = args;
20645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20646 if (!SWIG_IsOK(res1)) {
20647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20648 }
20649 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20653 wxPyEndAllowThreads(__tstate);
20654 if (PyErr_Occurred()) SWIG_fail;
20655 }
20656 {
20657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20658 }
20659 return resultobj;
20660 fail:
20661 return NULL;
20662 }
20663
20664
20665 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20666 PyObject *resultobj = 0;
20667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20668 bool result;
20669 void *argp1 = 0 ;
20670 int res1 = 0 ;
20671 PyObject *swig_obj[1] ;
20672
20673 if (!args) SWIG_fail;
20674 swig_obj[0] = args;
20675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20676 if (!SWIG_IsOK(res1)) {
20677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20678 }
20679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20680 {
20681 PyThreadState* __tstate = wxPyBeginAllowThreads();
20682 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20683 wxPyEndAllowThreads(__tstate);
20684 if (PyErr_Occurred()) SWIG_fail;
20685 }
20686 {
20687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20688 }
20689 return resultobj;
20690 fail:
20691 return NULL;
20692 }
20693
20694
20695 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20696 PyObject *resultobj = 0;
20697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20698 bool result;
20699 void *argp1 = 0 ;
20700 int res1 = 0 ;
20701 PyObject *swig_obj[1] ;
20702
20703 if (!args) SWIG_fail;
20704 swig_obj[0] = args;
20705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20706 if (!SWIG_IsOK(res1)) {
20707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20708 }
20709 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20710 {
20711 PyThreadState* __tstate = wxPyBeginAllowThreads();
20712 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20713 wxPyEndAllowThreads(__tstate);
20714 if (PyErr_Occurred()) SWIG_fail;
20715 }
20716 {
20717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20718 }
20719 return resultobj;
20720 fail:
20721 return NULL;
20722 }
20723
20724
20725 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20726 PyObject *resultobj = 0;
20727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20728 bool result;
20729 void *argp1 = 0 ;
20730 int res1 = 0 ;
20731 PyObject *swig_obj[1] ;
20732
20733 if (!args) SWIG_fail;
20734 swig_obj[0] = args;
20735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20736 if (!SWIG_IsOK(res1)) {
20737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20738 }
20739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (bool)(arg1)->LeftIsDown();
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 {
20747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20748 }
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20756 PyObject *resultobj = 0;
20757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20758 bool result;
20759 void *argp1 = 0 ;
20760 int res1 = 0 ;
20761 PyObject *swig_obj[1] ;
20762
20763 if (!args) SWIG_fail;
20764 swig_obj[0] = args;
20765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20768 }
20769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (bool)(arg1)->MiddleIsDown();
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 {
20777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20778 }
20779 return resultobj;
20780 fail:
20781 return NULL;
20782 }
20783
20784
20785 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20786 PyObject *resultobj = 0;
20787 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20788 bool result;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 PyObject *swig_obj[1] ;
20792
20793 if (!args) SWIG_fail;
20794 swig_obj[0] = args;
20795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20796 if (!SWIG_IsOK(res1)) {
20797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20798 }
20799 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (bool)(arg1)->RightIsDown();
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 {
20807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20808 }
20809 return resultobj;
20810 fail:
20811 return NULL;
20812 }
20813
20814
20815 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20816 PyObject *resultobj = 0;
20817 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20818 bool result;
20819 void *argp1 = 0 ;
20820 int res1 = 0 ;
20821 PyObject *swig_obj[1] ;
20822
20823 if (!args) SWIG_fail;
20824 swig_obj[0] = args;
20825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20826 if (!SWIG_IsOK(res1)) {
20827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20828 }
20829 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20830 {
20831 PyThreadState* __tstate = wxPyBeginAllowThreads();
20832 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20833 wxPyEndAllowThreads(__tstate);
20834 if (PyErr_Occurred()) SWIG_fail;
20835 }
20836 {
20837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20838 }
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20846 PyObject *resultobj = 0;
20847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20848 bool result;
20849 void *argp1 = 0 ;
20850 int res1 = 0 ;
20851 PyObject *swig_obj[1] ;
20852
20853 if (!args) SWIG_fail;
20854 swig_obj[0] = args;
20855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20856 if (!SWIG_IsOK(res1)) {
20857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20858 }
20859 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 {
20867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20868 }
20869 return resultobj;
20870 fail:
20871 return NULL;
20872 }
20873
20874
20875 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20876 PyObject *resultobj = 0;
20877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20878 bool result;
20879 void *argp1 = 0 ;
20880 int res1 = 0 ;
20881 PyObject *swig_obj[1] ;
20882
20883 if (!args) SWIG_fail;
20884 swig_obj[0] = args;
20885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20886 if (!SWIG_IsOK(res1)) {
20887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20888 }
20889 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20890 {
20891 PyThreadState* __tstate = wxPyBeginAllowThreads();
20892 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20893 wxPyEndAllowThreads(__tstate);
20894 if (PyErr_Occurred()) SWIG_fail;
20895 }
20896 {
20897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20898 }
20899 return resultobj;
20900 fail:
20901 return NULL;
20902 }
20903
20904
20905 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20906 PyObject *resultobj = 0;
20907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20908 bool result;
20909 void *argp1 = 0 ;
20910 int res1 = 0 ;
20911 PyObject *swig_obj[1] ;
20912
20913 if (!args) SWIG_fail;
20914 swig_obj[0] = args;
20915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20916 if (!SWIG_IsOK(res1)) {
20917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20918 }
20919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20923 wxPyEndAllowThreads(__tstate);
20924 if (PyErr_Occurred()) SWIG_fail;
20925 }
20926 {
20927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20928 }
20929 return resultobj;
20930 fail:
20931 return NULL;
20932 }
20933
20934
20935 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20936 PyObject *resultobj = 0;
20937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20938 wxPoint result;
20939 void *argp1 = 0 ;
20940 int res1 = 0 ;
20941 PyObject *swig_obj[1] ;
20942
20943 if (!args) SWIG_fail;
20944 swig_obj[0] = args;
20945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20946 if (!SWIG_IsOK(res1)) {
20947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20948 }
20949 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (arg1)->GetPosition();
20953 wxPyEndAllowThreads(__tstate);
20954 if (PyErr_Occurred()) SWIG_fail;
20955 }
20956 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20957 return resultobj;
20958 fail:
20959 return NULL;
20960 }
20961
20962
20963 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20964 PyObject *resultobj = 0;
20965 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20966 long *arg2 = (long *) 0 ;
20967 long *arg3 = (long *) 0 ;
20968 void *argp1 = 0 ;
20969 int res1 = 0 ;
20970 long temp2 ;
20971 int res2 = SWIG_TMPOBJ ;
20972 long temp3 ;
20973 int res3 = SWIG_TMPOBJ ;
20974 PyObject *swig_obj[1] ;
20975
20976 arg2 = &temp2;
20977 arg3 = &temp3;
20978 if (!args) SWIG_fail;
20979 swig_obj[0] = args;
20980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20981 if (!SWIG_IsOK(res1)) {
20982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20983 }
20984 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20985 {
20986 PyThreadState* __tstate = wxPyBeginAllowThreads();
20987 (arg1)->GetPosition(arg2,arg3);
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 resultobj = SWIG_Py_Void();
20992 if (SWIG_IsTmpObj(res2)) {
20993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20994 } else {
20995 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20997 }
20998 if (SWIG_IsTmpObj(res3)) {
20999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21000 } else {
21001 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21003 }
21004 return resultobj;
21005 fail:
21006 return NULL;
21007 }
21008
21009
21010 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21011 PyObject *resultobj = 0;
21012 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21013 wxDC *arg2 = 0 ;
21014 wxPoint result;
21015 void *argp1 = 0 ;
21016 int res1 = 0 ;
21017 void *argp2 = 0 ;
21018 int res2 = 0 ;
21019 PyObject * obj0 = 0 ;
21020 PyObject * obj1 = 0 ;
21021 char * kwnames[] = {
21022 (char *) "self",(char *) "dc", NULL
21023 };
21024
21025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21027 if (!SWIG_IsOK(res1)) {
21028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21029 }
21030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21032 if (!SWIG_IsOK(res2)) {
21033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21034 }
21035 if (!argp2) {
21036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21037 }
21038 arg2 = reinterpret_cast< wxDC * >(argp2);
21039 {
21040 PyThreadState* __tstate = wxPyBeginAllowThreads();
21041 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 PyObject *resultobj = 0;
21054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21055 int result;
21056 void *argp1 = 0 ;
21057 int res1 = 0 ;
21058 PyObject *swig_obj[1] ;
21059
21060 if (!args) SWIG_fail;
21061 swig_obj[0] = args;
21062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21063 if (!SWIG_IsOK(res1)) {
21064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21065 }
21066 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21067 {
21068 PyThreadState* __tstate = wxPyBeginAllowThreads();
21069 result = (int)((wxMouseEvent const *)arg1)->GetX();
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 resultobj = SWIG_From_int(static_cast< int >(result));
21074 return resultobj;
21075 fail:
21076 return NULL;
21077 }
21078
21079
21080 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081 PyObject *resultobj = 0;
21082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21083 int result;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 PyObject *swig_obj[1] ;
21087
21088 if (!args) SWIG_fail;
21089 swig_obj[0] = args;
21090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21091 if (!SWIG_IsOK(res1)) {
21092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21093 }
21094 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 result = (int)((wxMouseEvent const *)arg1)->GetY();
21098 wxPyEndAllowThreads(__tstate);
21099 if (PyErr_Occurred()) SWIG_fail;
21100 }
21101 resultobj = SWIG_From_int(static_cast< int >(result));
21102 return resultobj;
21103 fail:
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21109 PyObject *resultobj = 0;
21110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21111 int result;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 PyObject *swig_obj[1] ;
21115
21116 if (!args) SWIG_fail;
21117 swig_obj[0] = args;
21118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21119 if (!SWIG_IsOK(res1)) {
21120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21121 }
21122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = SWIG_From_int(static_cast< int >(result));
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *resultobj = 0;
21138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21139 int result;
21140 void *argp1 = 0 ;
21141 int res1 = 0 ;
21142 PyObject *swig_obj[1] ;
21143
21144 if (!args) SWIG_fail;
21145 swig_obj[0] = args;
21146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21147 if (!SWIG_IsOK(res1)) {
21148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21149 }
21150 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21151 {
21152 PyThreadState* __tstate = wxPyBeginAllowThreads();
21153 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = SWIG_From_int(static_cast< int >(result));
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21165 PyObject *resultobj = 0;
21166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21167 int result;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 PyObject *swig_obj[1] ;
21171
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21177 }
21178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21182 wxPyEndAllowThreads(__tstate);
21183 if (PyErr_Occurred()) SWIG_fail;
21184 }
21185 resultobj = SWIG_From_int(static_cast< int >(result));
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193 PyObject *resultobj = 0;
21194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21195 bool result;
21196 void *argp1 = 0 ;
21197 int res1 = 0 ;
21198 PyObject *swig_obj[1] ;
21199
21200 if (!args) SWIG_fail;
21201 swig_obj[0] = args;
21202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21205 }
21206 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21215 }
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21223 PyObject *resultobj = 0;
21224 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21225 int arg2 ;
21226 void *argp1 = 0 ;
21227 int res1 = 0 ;
21228 int val2 ;
21229 int ecode2 = 0 ;
21230 PyObject *swig_obj[2] ;
21231
21232 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21234 if (!SWIG_IsOK(res1)) {
21235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21236 }
21237 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21238 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21239 if (!SWIG_IsOK(ecode2)) {
21240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21241 }
21242 arg2 = static_cast< int >(val2);
21243 if (arg1) (arg1)->m_x = arg2;
21244
21245 resultobj = SWIG_Py_Void();
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21253 PyObject *resultobj = 0;
21254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21255 int result;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 PyObject *swig_obj[1] ;
21259
21260 if (!args) SWIG_fail;
21261 swig_obj[0] = args;
21262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21263 if (!SWIG_IsOK(res1)) {
21264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21265 }
21266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21267 result = (int) ((arg1)->m_x);
21268 resultobj = SWIG_From_int(static_cast< int >(result));
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21276 PyObject *resultobj = 0;
21277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21278 int arg2 ;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 int val2 ;
21282 int ecode2 = 0 ;
21283 PyObject *swig_obj[2] ;
21284
21285 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21287 if (!SWIG_IsOK(res1)) {
21288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21289 }
21290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21291 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21292 if (!SWIG_IsOK(ecode2)) {
21293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21294 }
21295 arg2 = static_cast< int >(val2);
21296 if (arg1) (arg1)->m_y = arg2;
21297
21298 resultobj = SWIG_Py_Void();
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21306 PyObject *resultobj = 0;
21307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21308 int result;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 PyObject *swig_obj[1] ;
21312
21313 if (!args) SWIG_fail;
21314 swig_obj[0] = args;
21315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21316 if (!SWIG_IsOK(res1)) {
21317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21318 }
21319 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21320 result = (int) ((arg1)->m_y);
21321 resultobj = SWIG_From_int(static_cast< int >(result));
21322 return resultobj;
21323 fail:
21324 return NULL;
21325 }
21326
21327
21328 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21329 PyObject *resultobj = 0;
21330 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21331 bool arg2 ;
21332 void *argp1 = 0 ;
21333 int res1 = 0 ;
21334 bool val2 ;
21335 int ecode2 = 0 ;
21336 PyObject *swig_obj[2] ;
21337
21338 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21340 if (!SWIG_IsOK(res1)) {
21341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21342 }
21343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21344 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21345 if (!SWIG_IsOK(ecode2)) {
21346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21347 }
21348 arg2 = static_cast< bool >(val2);
21349 if (arg1) (arg1)->m_leftDown = arg2;
21350
21351 resultobj = SWIG_Py_Void();
21352 return resultobj;
21353 fail:
21354 return NULL;
21355 }
21356
21357
21358 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21359 PyObject *resultobj = 0;
21360 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21361 bool result;
21362 void *argp1 = 0 ;
21363 int res1 = 0 ;
21364 PyObject *swig_obj[1] ;
21365
21366 if (!args) SWIG_fail;
21367 swig_obj[0] = args;
21368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21369 if (!SWIG_IsOK(res1)) {
21370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21371 }
21372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21373 result = (bool) ((arg1)->m_leftDown);
21374 {
21375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21376 }
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21384 PyObject *resultobj = 0;
21385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21386 bool arg2 ;
21387 void *argp1 = 0 ;
21388 int res1 = 0 ;
21389 bool val2 ;
21390 int ecode2 = 0 ;
21391 PyObject *swig_obj[2] ;
21392
21393 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21395 if (!SWIG_IsOK(res1)) {
21396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21397 }
21398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21399 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21400 if (!SWIG_IsOK(ecode2)) {
21401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21402 }
21403 arg2 = static_cast< bool >(val2);
21404 if (arg1) (arg1)->m_middleDown = arg2;
21405
21406 resultobj = SWIG_Py_Void();
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21414 PyObject *resultobj = 0;
21415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21416 bool result;
21417 void *argp1 = 0 ;
21418 int res1 = 0 ;
21419 PyObject *swig_obj[1] ;
21420
21421 if (!args) SWIG_fail;
21422 swig_obj[0] = args;
21423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21424 if (!SWIG_IsOK(res1)) {
21425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21426 }
21427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21428 result = (bool) ((arg1)->m_middleDown);
21429 {
21430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21431 }
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21439 PyObject *resultobj = 0;
21440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21441 bool arg2 ;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 bool val2 ;
21445 int ecode2 = 0 ;
21446 PyObject *swig_obj[2] ;
21447
21448 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21450 if (!SWIG_IsOK(res1)) {
21451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21452 }
21453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21454 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21455 if (!SWIG_IsOK(ecode2)) {
21456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21457 }
21458 arg2 = static_cast< bool >(val2);
21459 if (arg1) (arg1)->m_rightDown = arg2;
21460
21461 resultobj = SWIG_Py_Void();
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21471 bool result;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 PyObject *swig_obj[1] ;
21475
21476 if (!args) SWIG_fail;
21477 swig_obj[0] = args;
21478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21479 if (!SWIG_IsOK(res1)) {
21480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21481 }
21482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21483 result = (bool) ((arg1)->m_rightDown);
21484 {
21485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21486 }
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21494 PyObject *resultobj = 0;
21495 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21496 bool arg2 ;
21497 void *argp1 = 0 ;
21498 int res1 = 0 ;
21499 bool val2 ;
21500 int ecode2 = 0 ;
21501 PyObject *swig_obj[2] ;
21502
21503 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21505 if (!SWIG_IsOK(res1)) {
21506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21507 }
21508 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21509 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21510 if (!SWIG_IsOK(ecode2)) {
21511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21512 }
21513 arg2 = static_cast< bool >(val2);
21514 if (arg1) (arg1)->m_controlDown = arg2;
21515
21516 resultobj = SWIG_Py_Void();
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *resultobj = 0;
21525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21526 bool result;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 PyObject *swig_obj[1] ;
21530
21531 if (!args) SWIG_fail;
21532 swig_obj[0] = args;
21533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21534 if (!SWIG_IsOK(res1)) {
21535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21536 }
21537 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21538 result = (bool) ((arg1)->m_controlDown);
21539 {
21540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21541 }
21542 return resultobj;
21543 fail:
21544 return NULL;
21545 }
21546
21547
21548 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21549 PyObject *resultobj = 0;
21550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21551 bool arg2 ;
21552 void *argp1 = 0 ;
21553 int res1 = 0 ;
21554 bool val2 ;
21555 int ecode2 = 0 ;
21556 PyObject *swig_obj[2] ;
21557
21558 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21560 if (!SWIG_IsOK(res1)) {
21561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21562 }
21563 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21564 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21565 if (!SWIG_IsOK(ecode2)) {
21566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21567 }
21568 arg2 = static_cast< bool >(val2);
21569 if (arg1) (arg1)->m_shiftDown = arg2;
21570
21571 resultobj = SWIG_Py_Void();
21572 return resultobj;
21573 fail:
21574 return NULL;
21575 }
21576
21577
21578 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21579 PyObject *resultobj = 0;
21580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21581 bool result;
21582 void *argp1 = 0 ;
21583 int res1 = 0 ;
21584 PyObject *swig_obj[1] ;
21585
21586 if (!args) SWIG_fail;
21587 swig_obj[0] = args;
21588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21589 if (!SWIG_IsOK(res1)) {
21590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21591 }
21592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21593 result = (bool) ((arg1)->m_shiftDown);
21594 {
21595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21596 }
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21604 PyObject *resultobj = 0;
21605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21606 bool arg2 ;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 bool val2 ;
21610 int ecode2 = 0 ;
21611 PyObject *swig_obj[2] ;
21612
21613 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21615 if (!SWIG_IsOK(res1)) {
21616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21617 }
21618 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21619 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21620 if (!SWIG_IsOK(ecode2)) {
21621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21622 }
21623 arg2 = static_cast< bool >(val2);
21624 if (arg1) (arg1)->m_altDown = arg2;
21625
21626 resultobj = SWIG_Py_Void();
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 PyObject *resultobj = 0;
21635 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21636 bool result;
21637 void *argp1 = 0 ;
21638 int res1 = 0 ;
21639 PyObject *swig_obj[1] ;
21640
21641 if (!args) SWIG_fail;
21642 swig_obj[0] = args;
21643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21644 if (!SWIG_IsOK(res1)) {
21645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21646 }
21647 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21648 result = (bool) ((arg1)->m_altDown);
21649 {
21650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21651 }
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21659 PyObject *resultobj = 0;
21660 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21661 bool arg2 ;
21662 void *argp1 = 0 ;
21663 int res1 = 0 ;
21664 bool val2 ;
21665 int ecode2 = 0 ;
21666 PyObject *swig_obj[2] ;
21667
21668 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21670 if (!SWIG_IsOK(res1)) {
21671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21672 }
21673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21674 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21675 if (!SWIG_IsOK(ecode2)) {
21676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21677 }
21678 arg2 = static_cast< bool >(val2);
21679 if (arg1) (arg1)->m_metaDown = arg2;
21680
21681 resultobj = SWIG_Py_Void();
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21691 bool result;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 PyObject *swig_obj[1] ;
21695
21696 if (!args) SWIG_fail;
21697 swig_obj[0] = args;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21701 }
21702 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21703 result = (bool) ((arg1)->m_metaDown);
21704 {
21705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21706 }
21707 return resultobj;
21708 fail:
21709 return NULL;
21710 }
21711
21712
21713 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21714 PyObject *resultobj = 0;
21715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21716 int arg2 ;
21717 void *argp1 = 0 ;
21718 int res1 = 0 ;
21719 int val2 ;
21720 int ecode2 = 0 ;
21721 PyObject *swig_obj[2] ;
21722
21723 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21725 if (!SWIG_IsOK(res1)) {
21726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21727 }
21728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21729 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21730 if (!SWIG_IsOK(ecode2)) {
21731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21732 }
21733 arg2 = static_cast< int >(val2);
21734 if (arg1) (arg1)->m_wheelRotation = arg2;
21735
21736 resultobj = SWIG_Py_Void();
21737 return resultobj;
21738 fail:
21739 return NULL;
21740 }
21741
21742
21743 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21744 PyObject *resultobj = 0;
21745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21746 int result;
21747 void *argp1 = 0 ;
21748 int res1 = 0 ;
21749 PyObject *swig_obj[1] ;
21750
21751 if (!args) SWIG_fail;
21752 swig_obj[0] = args;
21753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21754 if (!SWIG_IsOK(res1)) {
21755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21756 }
21757 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21758 result = (int) ((arg1)->m_wheelRotation);
21759 resultobj = SWIG_From_int(static_cast< int >(result));
21760 return resultobj;
21761 fail:
21762 return NULL;
21763 }
21764
21765
21766 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21767 PyObject *resultobj = 0;
21768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21769 int arg2 ;
21770 void *argp1 = 0 ;
21771 int res1 = 0 ;
21772 int val2 ;
21773 int ecode2 = 0 ;
21774 PyObject *swig_obj[2] ;
21775
21776 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21778 if (!SWIG_IsOK(res1)) {
21779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21780 }
21781 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21782 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21783 if (!SWIG_IsOK(ecode2)) {
21784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21785 }
21786 arg2 = static_cast< int >(val2);
21787 if (arg1) (arg1)->m_wheelDelta = arg2;
21788
21789 resultobj = SWIG_Py_Void();
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21799 int result;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21809 }
21810 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21811 result = (int) ((arg1)->m_wheelDelta);
21812 resultobj = SWIG_From_int(static_cast< int >(result));
21813 return resultobj;
21814 fail:
21815 return NULL;
21816 }
21817
21818
21819 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 PyObject *resultobj = 0;
21821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21822 int arg2 ;
21823 void *argp1 = 0 ;
21824 int res1 = 0 ;
21825 int val2 ;
21826 int ecode2 = 0 ;
21827 PyObject *swig_obj[2] ;
21828
21829 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21831 if (!SWIG_IsOK(res1)) {
21832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21833 }
21834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21835 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21836 if (!SWIG_IsOK(ecode2)) {
21837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21838 }
21839 arg2 = static_cast< int >(val2);
21840 if (arg1) (arg1)->m_linesPerAction = arg2;
21841
21842 resultobj = SWIG_Py_Void();
21843 return resultobj;
21844 fail:
21845 return NULL;
21846 }
21847
21848
21849 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21850 PyObject *resultobj = 0;
21851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21852 int result;
21853 void *argp1 = 0 ;
21854 int res1 = 0 ;
21855 PyObject *swig_obj[1] ;
21856
21857 if (!args) SWIG_fail;
21858 swig_obj[0] = args;
21859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21860 if (!SWIG_IsOK(res1)) {
21861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21862 }
21863 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21864 result = (int) ((arg1)->m_linesPerAction);
21865 resultobj = SWIG_From_int(static_cast< int >(result));
21866 return resultobj;
21867 fail:
21868 return NULL;
21869 }
21870
21871
21872 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21873 PyObject *obj;
21874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21875 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21876 return SWIG_Py_Void();
21877 }
21878
21879 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21880 return SWIG_Python_InitShadowInstance(args);
21881 }
21882
21883 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21884 PyObject *resultobj = 0;
21885 int arg1 = (int) 0 ;
21886 int arg2 = (int) 0 ;
21887 wxSetCursorEvent *result = 0 ;
21888 int val1 ;
21889 int ecode1 = 0 ;
21890 int val2 ;
21891 int ecode2 = 0 ;
21892 PyObject * obj0 = 0 ;
21893 PyObject * obj1 = 0 ;
21894 char * kwnames[] = {
21895 (char *) "x",(char *) "y", NULL
21896 };
21897
21898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21899 if (obj0) {
21900 ecode1 = SWIG_AsVal_int(obj0, &val1);
21901 if (!SWIG_IsOK(ecode1)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21903 }
21904 arg1 = static_cast< int >(val1);
21905 }
21906 if (obj1) {
21907 ecode2 = SWIG_AsVal_int(obj1, &val2);
21908 if (!SWIG_IsOK(ecode2)) {
21909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21910 }
21911 arg2 = static_cast< int >(val2);
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21927 PyObject *resultobj = 0;
21928 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21929 int result;
21930 void *argp1 = 0 ;
21931 int res1 = 0 ;
21932 PyObject *swig_obj[1] ;
21933
21934 if (!args) SWIG_fail;
21935 swig_obj[0] = args;
21936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21939 }
21940 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21941 {
21942 PyThreadState* __tstate = wxPyBeginAllowThreads();
21943 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 resultobj = SWIG_From_int(static_cast< int >(result));
21948 return resultobj;
21949 fail:
21950 return NULL;
21951 }
21952
21953
21954 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21955 PyObject *resultobj = 0;
21956 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21957 int result;
21958 void *argp1 = 0 ;
21959 int res1 = 0 ;
21960 PyObject *swig_obj[1] ;
21961
21962 if (!args) SWIG_fail;
21963 swig_obj[0] = args;
21964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21965 if (!SWIG_IsOK(res1)) {
21966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21967 }
21968 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21972 wxPyEndAllowThreads(__tstate);
21973 if (PyErr_Occurred()) SWIG_fail;
21974 }
21975 resultobj = SWIG_From_int(static_cast< int >(result));
21976 return resultobj;
21977 fail:
21978 return NULL;
21979 }
21980
21981
21982 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21983 PyObject *resultobj = 0;
21984 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21985 wxCursor *arg2 = 0 ;
21986 void *argp1 = 0 ;
21987 int res1 = 0 ;
21988 void *argp2 = 0 ;
21989 int res2 = 0 ;
21990 PyObject * obj0 = 0 ;
21991 PyObject * obj1 = 0 ;
21992 char * kwnames[] = {
21993 (char *) "self",(char *) "cursor", NULL
21994 };
21995
21996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22000 }
22001 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22002 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22003 if (!SWIG_IsOK(res2)) {
22004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22005 }
22006 if (!argp2) {
22007 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22008 }
22009 arg2 = reinterpret_cast< wxCursor * >(argp2);
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 (arg1)->SetCursor((wxCursor const &)*arg2);
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 resultobj = SWIG_Py_Void();
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22024 PyObject *resultobj = 0;
22025 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22026 wxCursor *result = 0 ;
22027 void *argp1 = 0 ;
22028 int res1 = 0 ;
22029 PyObject *swig_obj[1] ;
22030
22031 if (!args) SWIG_fail;
22032 swig_obj[0] = args;
22033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22034 if (!SWIG_IsOK(res1)) {
22035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22036 }
22037 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 {
22041 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22042 result = (wxCursor *) &_result_ref;
22043 }
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 {
22048 wxCursor* resultptr = new wxCursor(*result);
22049 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22050 }
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 PyObject *resultobj = 0;
22059 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22060 bool result;
22061 void *argp1 = 0 ;
22062 int res1 = 0 ;
22063 PyObject *swig_obj[1] ;
22064
22065 if (!args) SWIG_fail;
22066 swig_obj[0] = args;
22067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22068 if (!SWIG_IsOK(res1)) {
22069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22070 }
22071 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 PyObject *obj;
22089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22090 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22091 return SWIG_Py_Void();
22092 }
22093
22094 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22095 return SWIG_Python_InitShadowInstance(args);
22096 }
22097
22098 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj = 0;
22100 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22101 wxKeyEvent *result = 0 ;
22102 int val1 ;
22103 int ecode1 = 0 ;
22104 PyObject * obj0 = 0 ;
22105 char * kwnames[] = {
22106 (char *) "eventType", NULL
22107 };
22108
22109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22110 if (obj0) {
22111 ecode1 = SWIG_AsVal_int(obj0, &val1);
22112 if (!SWIG_IsOK(ecode1)) {
22113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22114 }
22115 arg1 = static_cast< wxEventType >(val1);
22116 }
22117 {
22118 PyThreadState* __tstate = wxPyBeginAllowThreads();
22119 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22131 PyObject *resultobj = 0;
22132 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22133 int result;
22134 void *argp1 = 0 ;
22135 int res1 = 0 ;
22136 PyObject *swig_obj[1] ;
22137
22138 if (!args) SWIG_fail;
22139 swig_obj[0] = args;
22140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22141 if (!SWIG_IsOK(res1)) {
22142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22143 }
22144 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22145 {
22146 PyThreadState* __tstate = wxPyBeginAllowThreads();
22147 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22148 wxPyEndAllowThreads(__tstate);
22149 if (PyErr_Occurred()) SWIG_fail;
22150 }
22151 resultobj = SWIG_From_int(static_cast< int >(result));
22152 return resultobj;
22153 fail:
22154 return NULL;
22155 }
22156
22157
22158 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22159 PyObject *resultobj = 0;
22160 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22161 bool result;
22162 void *argp1 = 0 ;
22163 int res1 = 0 ;
22164 PyObject *swig_obj[1] ;
22165
22166 if (!args) SWIG_fail;
22167 swig_obj[0] = args;
22168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22169 if (!SWIG_IsOK(res1)) {
22170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22171 }
22172 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22173 {
22174 PyThreadState* __tstate = wxPyBeginAllowThreads();
22175 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22176 wxPyEndAllowThreads(__tstate);
22177 if (PyErr_Occurred()) SWIG_fail;
22178 }
22179 {
22180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22181 }
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22189 PyObject *resultobj = 0;
22190 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22191 bool result;
22192 void *argp1 = 0 ;
22193 int res1 = 0 ;
22194 PyObject *swig_obj[1] ;
22195
22196 if (!args) SWIG_fail;
22197 swig_obj[0] = args;
22198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22199 if (!SWIG_IsOK(res1)) {
22200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22201 }
22202 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 {
22210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22211 }
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22219 PyObject *resultobj = 0;
22220 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22221 bool result;
22222 void *argp1 = 0 ;
22223 int res1 = 0 ;
22224 PyObject *swig_obj[1] ;
22225
22226 if (!args) SWIG_fail;
22227 swig_obj[0] = args;
22228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22229 if (!SWIG_IsOK(res1)) {
22230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22231 }
22232 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22233 {
22234 PyThreadState* __tstate = wxPyBeginAllowThreads();
22235 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22236 wxPyEndAllowThreads(__tstate);
22237 if (PyErr_Occurred()) SWIG_fail;
22238 }
22239 {
22240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22241 }
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22249 PyObject *resultobj = 0;
22250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22251 bool result;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 PyObject *swig_obj[1] ;
22255
22256 if (!args) SWIG_fail;
22257 swig_obj[0] = args;
22258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22259 if (!SWIG_IsOK(res1)) {
22260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22261 }
22262 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 {
22270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22271 }
22272 return resultobj;
22273 fail:
22274 return NULL;
22275 }
22276
22277
22278 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22279 PyObject *resultobj = 0;
22280 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22281 bool result;
22282 void *argp1 = 0 ;
22283 int res1 = 0 ;
22284 PyObject *swig_obj[1] ;
22285
22286 if (!args) SWIG_fail;
22287 swig_obj[0] = args;
22288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22289 if (!SWIG_IsOK(res1)) {
22290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22291 }
22292 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22296 wxPyEndAllowThreads(__tstate);
22297 if (PyErr_Occurred()) SWIG_fail;
22298 }
22299 {
22300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22301 }
22302 return resultobj;
22303 fail:
22304 return NULL;
22305 }
22306
22307
22308 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22309 PyObject *resultobj = 0;
22310 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22311 bool result;
22312 void *argp1 = 0 ;
22313 int res1 = 0 ;
22314 PyObject *swig_obj[1] ;
22315
22316 if (!args) SWIG_fail;
22317 swig_obj[0] = args;
22318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22321 }
22322 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 {
22330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22331 }
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22339 PyObject *resultobj = 0;
22340 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22341 int result;
22342 void *argp1 = 0 ;
22343 int res1 = 0 ;
22344 PyObject *swig_obj[1] ;
22345
22346 if (!args) SWIG_fail;
22347 swig_obj[0] = args;
22348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22349 if (!SWIG_IsOK(res1)) {
22350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22351 }
22352 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22353 {
22354 PyThreadState* __tstate = wxPyBeginAllowThreads();
22355 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22356 wxPyEndAllowThreads(__tstate);
22357 if (PyErr_Occurred()) SWIG_fail;
22358 }
22359 resultobj = SWIG_From_int(static_cast< int >(result));
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22367 PyObject *resultobj = 0;
22368 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22369 int result;
22370 void *argp1 = 0 ;
22371 int res1 = 0 ;
22372 PyObject *swig_obj[1] ;
22373
22374 if (!args) SWIG_fail;
22375 swig_obj[0] = args;
22376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22377 if (!SWIG_IsOK(res1)) {
22378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22379 }
22380 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22381 {
22382 PyThreadState* __tstate = wxPyBeginAllowThreads();
22383 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 resultobj = SWIG_From_int(static_cast< int >(result));
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22395 PyObject *resultobj = 0;
22396 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22397 int arg2 ;
22398 void *argp1 = 0 ;
22399 int res1 = 0 ;
22400 int val2 ;
22401 int ecode2 = 0 ;
22402 PyObject * obj0 = 0 ;
22403 PyObject * obj1 = 0 ;
22404 char * kwnames[] = {
22405 (char *) "self",(char *) "uniChar", NULL
22406 };
22407
22408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22410 if (!SWIG_IsOK(res1)) {
22411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22412 }
22413 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22414 ecode2 = SWIG_AsVal_int(obj1, &val2);
22415 if (!SWIG_IsOK(ecode2)) {
22416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22417 }
22418 arg2 = static_cast< int >(val2);
22419 {
22420 PyThreadState* __tstate = wxPyBeginAllowThreads();
22421 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 resultobj = SWIG_Py_Void();
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 unsigned int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 unsigned int result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22491 wxPoint result;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 PyObject *swig_obj[1] ;
22495
22496 if (!args) SWIG_fail;
22497 swig_obj[0] = args;
22498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22499 if (!SWIG_IsOK(res1)) {
22500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22501 }
22502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 result = (arg1)->GetPosition();
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22517 PyObject *resultobj = 0;
22518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22519 long *arg2 = (long *) 0 ;
22520 long *arg3 = (long *) 0 ;
22521 void *argp1 = 0 ;
22522 int res1 = 0 ;
22523 long temp2 ;
22524 int res2 = SWIG_TMPOBJ ;
22525 long temp3 ;
22526 int res3 = SWIG_TMPOBJ ;
22527 PyObject *swig_obj[1] ;
22528
22529 arg2 = &temp2;
22530 arg3 = &temp3;
22531 if (!args) SWIG_fail;
22532 swig_obj[0] = args;
22533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22534 if (!SWIG_IsOK(res1)) {
22535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22536 }
22537 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 (arg1)->GetPosition(arg2,arg3);
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_Py_Void();
22545 if (SWIG_IsTmpObj(res2)) {
22546 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22547 } else {
22548 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22550 }
22551 if (SWIG_IsTmpObj(res3)) {
22552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22553 } else {
22554 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22556 }
22557 return resultobj;
22558 fail:
22559 return NULL;
22560 }
22561
22562
22563 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22564 PyObject *resultobj = 0;
22565 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22566 int result;
22567 void *argp1 = 0 ;
22568 int res1 = 0 ;
22569 PyObject *swig_obj[1] ;
22570
22571 if (!args) SWIG_fail;
22572 swig_obj[0] = args;
22573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22574 if (!SWIG_IsOK(res1)) {
22575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22576 }
22577 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22578 {
22579 PyThreadState* __tstate = wxPyBeginAllowThreads();
22580 result = (int)((wxKeyEvent const *)arg1)->GetX();
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 resultobj = SWIG_From_int(static_cast< int >(result));
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 PyObject *resultobj = 0;
22593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22594 int result;
22595 void *argp1 = 0 ;
22596 int res1 = 0 ;
22597 PyObject *swig_obj[1] ;
22598
22599 if (!args) SWIG_fail;
22600 swig_obj[0] = args;
22601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22602 if (!SWIG_IsOK(res1)) {
22603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22604 }
22605 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 result = (int)((wxKeyEvent const *)arg1)->GetY();
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_From_int(static_cast< int >(result));
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22620 PyObject *resultobj = 0;
22621 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22622 int arg2 ;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 int val2 ;
22626 int ecode2 = 0 ;
22627 PyObject *swig_obj[2] ;
22628
22629 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22631 if (!SWIG_IsOK(res1)) {
22632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22633 }
22634 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22635 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22636 if (!SWIG_IsOK(ecode2)) {
22637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22638 }
22639 arg2 = static_cast< int >(val2);
22640 if (arg1) (arg1)->m_x = arg2;
22641
22642 resultobj = SWIG_Py_Void();
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22650 PyObject *resultobj = 0;
22651 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22652 int result;
22653 void *argp1 = 0 ;
22654 int res1 = 0 ;
22655 PyObject *swig_obj[1] ;
22656
22657 if (!args) SWIG_fail;
22658 swig_obj[0] = args;
22659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22660 if (!SWIG_IsOK(res1)) {
22661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22662 }
22663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22664 result = (int) ((arg1)->m_x);
22665 resultobj = SWIG_From_int(static_cast< int >(result));
22666 return resultobj;
22667 fail:
22668 return NULL;
22669 }
22670
22671
22672 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22673 PyObject *resultobj = 0;
22674 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22675 int arg2 ;
22676 void *argp1 = 0 ;
22677 int res1 = 0 ;
22678 int val2 ;
22679 int ecode2 = 0 ;
22680 PyObject *swig_obj[2] ;
22681
22682 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22684 if (!SWIG_IsOK(res1)) {
22685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22686 }
22687 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22688 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22689 if (!SWIG_IsOK(ecode2)) {
22690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22691 }
22692 arg2 = static_cast< int >(val2);
22693 if (arg1) (arg1)->m_y = arg2;
22694
22695 resultobj = SWIG_Py_Void();
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22705 int result;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 PyObject *swig_obj[1] ;
22709
22710 if (!args) SWIG_fail;
22711 swig_obj[0] = args;
22712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22713 if (!SWIG_IsOK(res1)) {
22714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22715 }
22716 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22717 result = (int) ((arg1)->m_y);
22718 resultobj = SWIG_From_int(static_cast< int >(result));
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22726 PyObject *resultobj = 0;
22727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22728 long arg2 ;
22729 void *argp1 = 0 ;
22730 int res1 = 0 ;
22731 long val2 ;
22732 int ecode2 = 0 ;
22733 PyObject *swig_obj[2] ;
22734
22735 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22737 if (!SWIG_IsOK(res1)) {
22738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22739 }
22740 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22741 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22742 if (!SWIG_IsOK(ecode2)) {
22743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22744 }
22745 arg2 = static_cast< long >(val2);
22746 if (arg1) (arg1)->m_keyCode = arg2;
22747
22748 resultobj = SWIG_Py_Void();
22749 return resultobj;
22750 fail:
22751 return NULL;
22752 }
22753
22754
22755 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756 PyObject *resultobj = 0;
22757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22758 long result;
22759 void *argp1 = 0 ;
22760 int res1 = 0 ;
22761 PyObject *swig_obj[1] ;
22762
22763 if (!args) SWIG_fail;
22764 swig_obj[0] = args;
22765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22766 if (!SWIG_IsOK(res1)) {
22767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22768 }
22769 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22770 result = (long) ((arg1)->m_keyCode);
22771 resultobj = SWIG_From_long(static_cast< long >(result));
22772 return resultobj;
22773 fail:
22774 return NULL;
22775 }
22776
22777
22778 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22779 PyObject *resultobj = 0;
22780 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22781 bool arg2 ;
22782 void *argp1 = 0 ;
22783 int res1 = 0 ;
22784 bool val2 ;
22785 int ecode2 = 0 ;
22786 PyObject *swig_obj[2] ;
22787
22788 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22790 if (!SWIG_IsOK(res1)) {
22791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22792 }
22793 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22794 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22795 if (!SWIG_IsOK(ecode2)) {
22796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22797 }
22798 arg2 = static_cast< bool >(val2);
22799 if (arg1) (arg1)->m_controlDown = arg2;
22800
22801 resultobj = SWIG_Py_Void();
22802 return resultobj;
22803 fail:
22804 return NULL;
22805 }
22806
22807
22808 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22809 PyObject *resultobj = 0;
22810 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22811 bool result;
22812 void *argp1 = 0 ;
22813 int res1 = 0 ;
22814 PyObject *swig_obj[1] ;
22815
22816 if (!args) SWIG_fail;
22817 swig_obj[0] = args;
22818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22819 if (!SWIG_IsOK(res1)) {
22820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22821 }
22822 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22823 result = (bool) ((arg1)->m_controlDown);
22824 {
22825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22826 }
22827 return resultobj;
22828 fail:
22829 return NULL;
22830 }
22831
22832
22833 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22834 PyObject *resultobj = 0;
22835 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22836 bool arg2 ;
22837 void *argp1 = 0 ;
22838 int res1 = 0 ;
22839 bool val2 ;
22840 int ecode2 = 0 ;
22841 PyObject *swig_obj[2] ;
22842
22843 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22845 if (!SWIG_IsOK(res1)) {
22846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22847 }
22848 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22849 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22850 if (!SWIG_IsOK(ecode2)) {
22851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22852 }
22853 arg2 = static_cast< bool >(val2);
22854 if (arg1) (arg1)->m_shiftDown = arg2;
22855
22856 resultobj = SWIG_Py_Void();
22857 return resultobj;
22858 fail:
22859 return NULL;
22860 }
22861
22862
22863 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22864 PyObject *resultobj = 0;
22865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22866 bool result;
22867 void *argp1 = 0 ;
22868 int res1 = 0 ;
22869 PyObject *swig_obj[1] ;
22870
22871 if (!args) SWIG_fail;
22872 swig_obj[0] = args;
22873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22874 if (!SWIG_IsOK(res1)) {
22875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22876 }
22877 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22878 result = (bool) ((arg1)->m_shiftDown);
22879 {
22880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22881 }
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22889 PyObject *resultobj = 0;
22890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22891 bool arg2 ;
22892 void *argp1 = 0 ;
22893 int res1 = 0 ;
22894 bool val2 ;
22895 int ecode2 = 0 ;
22896 PyObject *swig_obj[2] ;
22897
22898 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22900 if (!SWIG_IsOK(res1)) {
22901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22902 }
22903 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22904 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22905 if (!SWIG_IsOK(ecode2)) {
22906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22907 }
22908 arg2 = static_cast< bool >(val2);
22909 if (arg1) (arg1)->m_altDown = arg2;
22910
22911 resultobj = SWIG_Py_Void();
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22919 PyObject *resultobj = 0;
22920 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22921 bool result;
22922 void *argp1 = 0 ;
22923 int res1 = 0 ;
22924 PyObject *swig_obj[1] ;
22925
22926 if (!args) SWIG_fail;
22927 swig_obj[0] = args;
22928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22929 if (!SWIG_IsOK(res1)) {
22930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22931 }
22932 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22933 result = (bool) ((arg1)->m_altDown);
22934 {
22935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22936 }
22937 return resultobj;
22938 fail:
22939 return NULL;
22940 }
22941
22942
22943 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22944 PyObject *resultobj = 0;
22945 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22946 bool arg2 ;
22947 void *argp1 = 0 ;
22948 int res1 = 0 ;
22949 bool val2 ;
22950 int ecode2 = 0 ;
22951 PyObject *swig_obj[2] ;
22952
22953 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22955 if (!SWIG_IsOK(res1)) {
22956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22957 }
22958 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22959 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22960 if (!SWIG_IsOK(ecode2)) {
22961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22962 }
22963 arg2 = static_cast< bool >(val2);
22964 if (arg1) (arg1)->m_metaDown = arg2;
22965
22966 resultobj = SWIG_Py_Void();
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22974 PyObject *resultobj = 0;
22975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22976 bool result;
22977 void *argp1 = 0 ;
22978 int res1 = 0 ;
22979 PyObject *swig_obj[1] ;
22980
22981 if (!args) SWIG_fail;
22982 swig_obj[0] = args;
22983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22984 if (!SWIG_IsOK(res1)) {
22985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22986 }
22987 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22988 result = (bool) ((arg1)->m_metaDown);
22989 {
22990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22991 }
22992 return resultobj;
22993 fail:
22994 return NULL;
22995 }
22996
22997
22998 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22999 PyObject *resultobj = 0;
23000 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23001 bool arg2 ;
23002 void *argp1 = 0 ;
23003 int res1 = 0 ;
23004 bool val2 ;
23005 int ecode2 = 0 ;
23006 PyObject *swig_obj[2] ;
23007
23008 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23010 if (!SWIG_IsOK(res1)) {
23011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23012 }
23013 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23014 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23015 if (!SWIG_IsOK(ecode2)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23017 }
23018 arg2 = static_cast< bool >(val2);
23019 if (arg1) (arg1)->m_scanCode = arg2;
23020
23021 resultobj = SWIG_Py_Void();
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23029 PyObject *resultobj = 0;
23030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23031 bool result;
23032 void *argp1 = 0 ;
23033 int res1 = 0 ;
23034 PyObject *swig_obj[1] ;
23035
23036 if (!args) SWIG_fail;
23037 swig_obj[0] = args;
23038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23039 if (!SWIG_IsOK(res1)) {
23040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23041 }
23042 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23043 result = (bool) ((arg1)->m_scanCode);
23044 {
23045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23046 }
23047 return resultobj;
23048 fail:
23049 return NULL;
23050 }
23051
23052
23053 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23054 PyObject *resultobj = 0;
23055 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23056 unsigned int arg2 ;
23057 void *argp1 = 0 ;
23058 int res1 = 0 ;
23059 unsigned int val2 ;
23060 int ecode2 = 0 ;
23061 PyObject *swig_obj[2] ;
23062
23063 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23065 if (!SWIG_IsOK(res1)) {
23066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23067 }
23068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23069 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23070 if (!SWIG_IsOK(ecode2)) {
23071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23072 }
23073 arg2 = static_cast< unsigned int >(val2);
23074 if (arg1) (arg1)->m_rawCode = arg2;
23075
23076 resultobj = SWIG_Py_Void();
23077 return resultobj;
23078 fail:
23079 return NULL;
23080 }
23081
23082
23083 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23084 PyObject *resultobj = 0;
23085 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23086 unsigned int result;
23087 void *argp1 = 0 ;
23088 int res1 = 0 ;
23089 PyObject *swig_obj[1] ;
23090
23091 if (!args) SWIG_fail;
23092 swig_obj[0] = args;
23093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23094 if (!SWIG_IsOK(res1)) {
23095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23096 }
23097 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23098 result = (unsigned int) ((arg1)->m_rawCode);
23099 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23107 PyObject *resultobj = 0;
23108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23109 unsigned int arg2 ;
23110 void *argp1 = 0 ;
23111 int res1 = 0 ;
23112 unsigned int val2 ;
23113 int ecode2 = 0 ;
23114 PyObject *swig_obj[2] ;
23115
23116 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23118 if (!SWIG_IsOK(res1)) {
23119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23120 }
23121 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23122 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23123 if (!SWIG_IsOK(ecode2)) {
23124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23125 }
23126 arg2 = static_cast< unsigned int >(val2);
23127 if (arg1) (arg1)->m_rawFlags = arg2;
23128
23129 resultobj = SWIG_Py_Void();
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *resultobj = 0;
23138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23139 unsigned int result;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 PyObject *swig_obj[1] ;
23143
23144 if (!args) SWIG_fail;
23145 swig_obj[0] = args;
23146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23147 if (!SWIG_IsOK(res1)) {
23148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23149 }
23150 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23151 result = (unsigned int) ((arg1)->m_rawFlags);
23152 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23153 return resultobj;
23154 fail:
23155 return NULL;
23156 }
23157
23158
23159 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23160 PyObject *obj;
23161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23162 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23163 return SWIG_Py_Void();
23164 }
23165
23166 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23167 return SWIG_Python_InitShadowInstance(args);
23168 }
23169
23170 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23171 PyObject *resultobj = 0;
23172 wxSize const &arg1_defvalue = wxDefaultSize ;
23173 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23174 int arg2 = (int) 0 ;
23175 wxSizeEvent *result = 0 ;
23176 wxSize temp1 ;
23177 int val2 ;
23178 int ecode2 = 0 ;
23179 PyObject * obj0 = 0 ;
23180 PyObject * obj1 = 0 ;
23181 char * kwnames[] = {
23182 (char *) "sz",(char *) "winid", NULL
23183 };
23184
23185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23186 if (obj0) {
23187 {
23188 arg1 = &temp1;
23189 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23190 }
23191 }
23192 if (obj1) {
23193 ecode2 = SWIG_AsVal_int(obj1, &val2);
23194 if (!SWIG_IsOK(ecode2)) {
23195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23196 }
23197 arg2 = static_cast< int >(val2);
23198 }
23199 {
23200 PyThreadState* __tstate = wxPyBeginAllowThreads();
23201 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23202 wxPyEndAllowThreads(__tstate);
23203 if (PyErr_Occurred()) SWIG_fail;
23204 }
23205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23215 wxSize result;
23216 void *argp1 = 0 ;
23217 int res1 = 0 ;
23218 PyObject *swig_obj[1] ;
23219
23220 if (!args) SWIG_fail;
23221 swig_obj[0] = args;
23222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23223 if (!SWIG_IsOK(res1)) {
23224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23225 }
23226 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = ((wxSizeEvent const *)arg1)->GetSize();
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23234 return resultobj;
23235 fail:
23236 return NULL;
23237 }
23238
23239
23240 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23241 PyObject *resultobj = 0;
23242 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23243 wxRect result;
23244 void *argp1 = 0 ;
23245 int res1 = 0 ;
23246 PyObject *swig_obj[1] ;
23247
23248 if (!args) SWIG_fail;
23249 swig_obj[0] = args;
23250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23251 if (!SWIG_IsOK(res1)) {
23252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23253 }
23254 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23255 {
23256 PyThreadState* __tstate = wxPyBeginAllowThreads();
23257 result = ((wxSizeEvent const *)arg1)->GetRect();
23258 wxPyEndAllowThreads(__tstate);
23259 if (PyErr_Occurred()) SWIG_fail;
23260 }
23261 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23262 return resultobj;
23263 fail:
23264 return NULL;
23265 }
23266
23267
23268 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23269 PyObject *resultobj = 0;
23270 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23271 wxRect arg2 ;
23272 void *argp1 = 0 ;
23273 int res1 = 0 ;
23274 void *argp2 ;
23275 int res2 = 0 ;
23276 PyObject * obj0 = 0 ;
23277 PyObject * obj1 = 0 ;
23278 char * kwnames[] = {
23279 (char *) "self",(char *) "rect", NULL
23280 };
23281
23282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23284 if (!SWIG_IsOK(res1)) {
23285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23286 }
23287 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23288 {
23289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23290 if (!SWIG_IsOK(res2)) {
23291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23292 }
23293 if (!argp2) {
23294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23295 } else {
23296 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23297 arg2 = *temp;
23298 if (SWIG_IsNewObj(res2)) delete temp;
23299 }
23300 }
23301 {
23302 PyThreadState* __tstate = wxPyBeginAllowThreads();
23303 (arg1)->SetRect(arg2);
23304 wxPyEndAllowThreads(__tstate);
23305 if (PyErr_Occurred()) SWIG_fail;
23306 }
23307 resultobj = SWIG_Py_Void();
23308 return resultobj;
23309 fail:
23310 return NULL;
23311 }
23312
23313
23314 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj = 0;
23316 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23317 wxSize arg2 ;
23318 void *argp1 = 0 ;
23319 int res1 = 0 ;
23320 void *argp2 ;
23321 int res2 = 0 ;
23322 PyObject * obj0 = 0 ;
23323 PyObject * obj1 = 0 ;
23324 char * kwnames[] = {
23325 (char *) "self",(char *) "size", NULL
23326 };
23327
23328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23330 if (!SWIG_IsOK(res1)) {
23331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23332 }
23333 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23334 {
23335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23336 if (!SWIG_IsOK(res2)) {
23337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23338 }
23339 if (!argp2) {
23340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23341 } else {
23342 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23343 arg2 = *temp;
23344 if (SWIG_IsNewObj(res2)) delete temp;
23345 }
23346 }
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 wxSizeEvent_SetSize(arg1,arg2);
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 resultobj = SWIG_Py_Void();
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23361 PyObject *resultobj = 0;
23362 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23363 wxSize *arg2 = (wxSize *) 0 ;
23364 void *argp1 = 0 ;
23365 int res1 = 0 ;
23366 void *argp2 = 0 ;
23367 int res2 = 0 ;
23368 PyObject *swig_obj[2] ;
23369
23370 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23372 if (!SWIG_IsOK(res1)) {
23373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23374 }
23375 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23376 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23377 if (!SWIG_IsOK(res2)) {
23378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23379 }
23380 arg2 = reinterpret_cast< wxSize * >(argp2);
23381 if (arg1) (arg1)->m_size = *arg2;
23382
23383 resultobj = SWIG_Py_Void();
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23391 PyObject *resultobj = 0;
23392 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23393 wxSize *result = 0 ;
23394 void *argp1 = 0 ;
23395 int res1 = 0 ;
23396 PyObject *swig_obj[1] ;
23397
23398 if (!args) SWIG_fail;
23399 swig_obj[0] = args;
23400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23401 if (!SWIG_IsOK(res1)) {
23402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23403 }
23404 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23405 result = (wxSize *)& ((arg1)->m_size);
23406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23414 PyObject *resultobj = 0;
23415 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23416 wxRect *arg2 = (wxRect *) 0 ;
23417 void *argp1 = 0 ;
23418 int res1 = 0 ;
23419 void *argp2 = 0 ;
23420 int res2 = 0 ;
23421 PyObject *swig_obj[2] ;
23422
23423 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23425 if (!SWIG_IsOK(res1)) {
23426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23427 }
23428 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23429 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23430 if (!SWIG_IsOK(res2)) {
23431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23432 }
23433 arg2 = reinterpret_cast< wxRect * >(argp2);
23434 if (arg1) (arg1)->m_rect = *arg2;
23435
23436 resultobj = SWIG_Py_Void();
23437 return resultobj;
23438 fail:
23439 return NULL;
23440 }
23441
23442
23443 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23444 PyObject *resultobj = 0;
23445 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23446 wxRect *result = 0 ;
23447 void *argp1 = 0 ;
23448 int res1 = 0 ;
23449 PyObject *swig_obj[1] ;
23450
23451 if (!args) SWIG_fail;
23452 swig_obj[0] = args;
23453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23454 if (!SWIG_IsOK(res1)) {
23455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23456 }
23457 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23458 result = (wxRect *)& ((arg1)->m_rect);
23459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23460 return resultobj;
23461 fail:
23462 return NULL;
23463 }
23464
23465
23466 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23467 PyObject *obj;
23468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23469 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23470 return SWIG_Py_Void();
23471 }
23472
23473 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23474 return SWIG_Python_InitShadowInstance(args);
23475 }
23476
23477 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj = 0;
23479 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23480 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23481 int arg2 = (int) 0 ;
23482 wxMoveEvent *result = 0 ;
23483 wxPoint temp1 ;
23484 int val2 ;
23485 int ecode2 = 0 ;
23486 PyObject * obj0 = 0 ;
23487 PyObject * obj1 = 0 ;
23488 char * kwnames[] = {
23489 (char *) "pos",(char *) "winid", NULL
23490 };
23491
23492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23493 if (obj0) {
23494 {
23495 arg1 = &temp1;
23496 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23497 }
23498 }
23499 if (obj1) {
23500 ecode2 = SWIG_AsVal_int(obj1, &val2);
23501 if (!SWIG_IsOK(ecode2)) {
23502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23503 }
23504 arg2 = static_cast< int >(val2);
23505 }
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23509 wxPyEndAllowThreads(__tstate);
23510 if (PyErr_Occurred()) SWIG_fail;
23511 }
23512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23520 PyObject *resultobj = 0;
23521 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23522 wxPoint result;
23523 void *argp1 = 0 ;
23524 int res1 = 0 ;
23525 PyObject *swig_obj[1] ;
23526
23527 if (!args) SWIG_fail;
23528 swig_obj[0] = args;
23529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23530 if (!SWIG_IsOK(res1)) {
23531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23532 }
23533 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 result = ((wxMoveEvent const *)arg1)->GetPosition();
23537 wxPyEndAllowThreads(__tstate);
23538 if (PyErr_Occurred()) SWIG_fail;
23539 }
23540 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23541 return resultobj;
23542 fail:
23543 return NULL;
23544 }
23545
23546
23547 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23548 PyObject *resultobj = 0;
23549 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23550 wxRect result;
23551 void *argp1 = 0 ;
23552 int res1 = 0 ;
23553 PyObject *swig_obj[1] ;
23554
23555 if (!args) SWIG_fail;
23556 swig_obj[0] = args;
23557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23558 if (!SWIG_IsOK(res1)) {
23559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23560 }
23561 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23562 {
23563 PyThreadState* __tstate = wxPyBeginAllowThreads();
23564 result = ((wxMoveEvent const *)arg1)->GetRect();
23565 wxPyEndAllowThreads(__tstate);
23566 if (PyErr_Occurred()) SWIG_fail;
23567 }
23568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj = 0;
23577 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23578 wxRect *arg2 = 0 ;
23579 void *argp1 = 0 ;
23580 int res1 = 0 ;
23581 wxRect temp2 ;
23582 PyObject * obj0 = 0 ;
23583 PyObject * obj1 = 0 ;
23584 char * kwnames[] = {
23585 (char *) "self",(char *) "rect", NULL
23586 };
23587
23588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23590 if (!SWIG_IsOK(res1)) {
23591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23592 }
23593 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23594 {
23595 arg2 = &temp2;
23596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23597 }
23598 {
23599 PyThreadState* __tstate = wxPyBeginAllowThreads();
23600 (arg1)->SetRect((wxRect const &)*arg2);
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 resultobj = SWIG_Py_Void();
23605 return resultobj;
23606 fail:
23607 return NULL;
23608 }
23609
23610
23611 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23612 PyObject *resultobj = 0;
23613 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23614 wxPoint *arg2 = 0 ;
23615 void *argp1 = 0 ;
23616 int res1 = 0 ;
23617 wxPoint temp2 ;
23618 PyObject * obj0 = 0 ;
23619 PyObject * obj1 = 0 ;
23620 char * kwnames[] = {
23621 (char *) "self",(char *) "pos", NULL
23622 };
23623
23624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23626 if (!SWIG_IsOK(res1)) {
23627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23628 }
23629 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23630 {
23631 arg2 = &temp2;
23632 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23633 }
23634 {
23635 PyThreadState* __tstate = wxPyBeginAllowThreads();
23636 (arg1)->SetPosition((wxPoint const &)*arg2);
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 resultobj = SWIG_Py_Void();
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *obj;
23649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23650 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23651 return SWIG_Py_Void();
23652 }
23653
23654 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23655 return SWIG_Python_InitShadowInstance(args);
23656 }
23657
23658 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23659 PyObject *resultobj = 0;
23660 int arg1 = (int) 0 ;
23661 wxPaintEvent *result = 0 ;
23662 int val1 ;
23663 int ecode1 = 0 ;
23664 PyObject * obj0 = 0 ;
23665 char * kwnames[] = {
23666 (char *) "Id", NULL
23667 };
23668
23669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23670 if (obj0) {
23671 ecode1 = SWIG_AsVal_int(obj0, &val1);
23672 if (!SWIG_IsOK(ecode1)) {
23673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23674 }
23675 arg1 = static_cast< int >(val1);
23676 }
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23691 PyObject *obj;
23692 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23693 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23694 return SWIG_Py_Void();
23695 }
23696
23697 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698 return SWIG_Python_InitShadowInstance(args);
23699 }
23700
23701 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23702 PyObject *resultobj = 0;
23703 int arg1 = (int) 0 ;
23704 wxNcPaintEvent *result = 0 ;
23705 int val1 ;
23706 int ecode1 = 0 ;
23707 PyObject * obj0 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "winid", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23713 if (obj0) {
23714 ecode1 = SWIG_AsVal_int(obj0, &val1);
23715 if (!SWIG_IsOK(ecode1)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23717 }
23718 arg1 = static_cast< int >(val1);
23719 }
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23734 PyObject *obj;
23735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23736 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23737 return SWIG_Py_Void();
23738 }
23739
23740 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 return SWIG_Python_InitShadowInstance(args);
23742 }
23743
23744 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj = 0;
23746 int arg1 = (int) 0 ;
23747 wxDC *arg2 = (wxDC *) NULL ;
23748 wxEraseEvent *result = 0 ;
23749 int val1 ;
23750 int ecode1 = 0 ;
23751 void *argp2 = 0 ;
23752 int res2 = 0 ;
23753 PyObject * obj0 = 0 ;
23754 PyObject * obj1 = 0 ;
23755 char * kwnames[] = {
23756 (char *) "Id",(char *) "dc", NULL
23757 };
23758
23759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23760 if (obj0) {
23761 ecode1 = SWIG_AsVal_int(obj0, &val1);
23762 if (!SWIG_IsOK(ecode1)) {
23763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23764 }
23765 arg1 = static_cast< int >(val1);
23766 }
23767 if (obj1) {
23768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23769 if (!SWIG_IsOK(res2)) {
23770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23771 }
23772 arg2 = reinterpret_cast< wxDC * >(argp2);
23773 }
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23777 wxPyEndAllowThreads(__tstate);
23778 if (PyErr_Occurred()) SWIG_fail;
23779 }
23780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23781 return resultobj;
23782 fail:
23783 return NULL;
23784 }
23785
23786
23787 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23788 PyObject *resultobj = 0;
23789 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23790 wxDC *result = 0 ;
23791 void *argp1 = 0 ;
23792 int res1 = 0 ;
23793 PyObject *swig_obj[1] ;
23794
23795 if (!args) SWIG_fail;
23796 swig_obj[0] = args;
23797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23798 if (!SWIG_IsOK(res1)) {
23799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23800 }
23801 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23805 wxPyEndAllowThreads(__tstate);
23806 if (PyErr_Occurred()) SWIG_fail;
23807 }
23808 {
23809 resultobj = wxPyMake_wxObject(result, (bool)0);
23810 }
23811 return resultobj;
23812 fail:
23813 return NULL;
23814 }
23815
23816
23817 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23818 PyObject *obj;
23819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23820 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23821 return SWIG_Py_Void();
23822 }
23823
23824 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 return SWIG_Python_InitShadowInstance(args);
23826 }
23827
23828 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23829 PyObject *resultobj = 0;
23830 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23831 int arg2 = (int) 0 ;
23832 wxFocusEvent *result = 0 ;
23833 int val1 ;
23834 int ecode1 = 0 ;
23835 int val2 ;
23836 int ecode2 = 0 ;
23837 PyObject * obj0 = 0 ;
23838 PyObject * obj1 = 0 ;
23839 char * kwnames[] = {
23840 (char *) "type",(char *) "winid", NULL
23841 };
23842
23843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23844 if (obj0) {
23845 ecode1 = SWIG_AsVal_int(obj0, &val1);
23846 if (!SWIG_IsOK(ecode1)) {
23847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23848 }
23849 arg1 = static_cast< wxEventType >(val1);
23850 }
23851 if (obj1) {
23852 ecode2 = SWIG_AsVal_int(obj1, &val2);
23853 if (!SWIG_IsOK(ecode2)) {
23854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23855 }
23856 arg2 = static_cast< int >(val2);
23857 }
23858 {
23859 PyThreadState* __tstate = wxPyBeginAllowThreads();
23860 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23861 wxPyEndAllowThreads(__tstate);
23862 if (PyErr_Occurred()) SWIG_fail;
23863 }
23864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23865 return resultobj;
23866 fail:
23867 return NULL;
23868 }
23869
23870
23871 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23872 PyObject *resultobj = 0;
23873 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23874 wxWindow *result = 0 ;
23875 void *argp1 = 0 ;
23876 int res1 = 0 ;
23877 PyObject *swig_obj[1] ;
23878
23879 if (!args) SWIG_fail;
23880 swig_obj[0] = args;
23881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23882 if (!SWIG_IsOK(res1)) {
23883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23884 }
23885 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23886 {
23887 PyThreadState* __tstate = wxPyBeginAllowThreads();
23888 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23889 wxPyEndAllowThreads(__tstate);
23890 if (PyErr_Occurred()) SWIG_fail;
23891 }
23892 {
23893 resultobj = wxPyMake_wxObject(result, (bool)0);
23894 }
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj = 0;
23903 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23904 wxWindow *arg2 = (wxWindow *) 0 ;
23905 void *argp1 = 0 ;
23906 int res1 = 0 ;
23907 void *argp2 = 0 ;
23908 int res2 = 0 ;
23909 PyObject * obj0 = 0 ;
23910 PyObject * obj1 = 0 ;
23911 char * kwnames[] = {
23912 (char *) "self",(char *) "win", NULL
23913 };
23914
23915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23917 if (!SWIG_IsOK(res1)) {
23918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23919 }
23920 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23922 if (!SWIG_IsOK(res2)) {
23923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23924 }
23925 arg2 = reinterpret_cast< wxWindow * >(argp2);
23926 {
23927 PyThreadState* __tstate = wxPyBeginAllowThreads();
23928 (arg1)->SetWindow(arg2);
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 resultobj = SWIG_Py_Void();
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23940 PyObject *obj;
23941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23942 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23943 return SWIG_Py_Void();
23944 }
23945
23946 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23947 return SWIG_Python_InitShadowInstance(args);
23948 }
23949
23950 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj = 0;
23952 wxWindow *arg1 = (wxWindow *) NULL ;
23953 wxChildFocusEvent *result = 0 ;
23954 void *argp1 = 0 ;
23955 int res1 = 0 ;
23956 PyObject * obj0 = 0 ;
23957 char * kwnames[] = {
23958 (char *) "win", NULL
23959 };
23960
23961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23962 if (obj0) {
23963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23964 if (!SWIG_IsOK(res1)) {
23965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23966 }
23967 arg1 = reinterpret_cast< wxWindow * >(argp1);
23968 }
23969 {
23970 PyThreadState* __tstate = wxPyBeginAllowThreads();
23971 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23972 wxPyEndAllowThreads(__tstate);
23973 if (PyErr_Occurred()) SWIG_fail;
23974 }
23975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23976 return resultobj;
23977 fail:
23978 return NULL;
23979 }
23980
23981
23982 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23983 PyObject *resultobj = 0;
23984 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23985 wxWindow *result = 0 ;
23986 void *argp1 = 0 ;
23987 int res1 = 0 ;
23988 PyObject *swig_obj[1] ;
23989
23990 if (!args) SWIG_fail;
23991 swig_obj[0] = args;
23992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23993 if (!SWIG_IsOK(res1)) {
23994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23995 }
23996 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23997 {
23998 PyThreadState* __tstate = wxPyBeginAllowThreads();
23999 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24000 wxPyEndAllowThreads(__tstate);
24001 if (PyErr_Occurred()) SWIG_fail;
24002 }
24003 {
24004 resultobj = wxPyMake_wxObject(result, (bool)0);
24005 }
24006 return resultobj;
24007 fail:
24008 return NULL;
24009 }
24010
24011
24012 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 PyObject *obj;
24014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24015 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24016 return SWIG_Py_Void();
24017 }
24018
24019 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 return SWIG_Python_InitShadowInstance(args);
24021 }
24022
24023 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24024 PyObject *resultobj = 0;
24025 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24026 bool arg2 = (bool) true ;
24027 int arg3 = (int) 0 ;
24028 wxActivateEvent *result = 0 ;
24029 int val1 ;
24030 int ecode1 = 0 ;
24031 bool val2 ;
24032 int ecode2 = 0 ;
24033 int val3 ;
24034 int ecode3 = 0 ;
24035 PyObject * obj0 = 0 ;
24036 PyObject * obj1 = 0 ;
24037 PyObject * obj2 = 0 ;
24038 char * kwnames[] = {
24039 (char *) "type",(char *) "active",(char *) "Id", NULL
24040 };
24041
24042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24043 if (obj0) {
24044 ecode1 = SWIG_AsVal_int(obj0, &val1);
24045 if (!SWIG_IsOK(ecode1)) {
24046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24047 }
24048 arg1 = static_cast< wxEventType >(val1);
24049 }
24050 if (obj1) {
24051 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24052 if (!SWIG_IsOK(ecode2)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24054 }
24055 arg2 = static_cast< bool >(val2);
24056 }
24057 if (obj2) {
24058 ecode3 = SWIG_AsVal_int(obj2, &val3);
24059 if (!SWIG_IsOK(ecode3)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24061 }
24062 arg3 = static_cast< int >(val3);
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24071 return resultobj;
24072 fail:
24073 return NULL;
24074 }
24075
24076
24077 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24078 PyObject *resultobj = 0;
24079 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24080 bool result;
24081 void *argp1 = 0 ;
24082 int res1 = 0 ;
24083 PyObject *swig_obj[1] ;
24084
24085 if (!args) SWIG_fail;
24086 swig_obj[0] = args;
24087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24088 if (!SWIG_IsOK(res1)) {
24089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24090 }
24091 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24092 {
24093 PyThreadState* __tstate = wxPyBeginAllowThreads();
24094 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 {
24099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24100 }
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24108 PyObject *obj;
24109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24110 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24111 return SWIG_Py_Void();
24112 }
24113
24114 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 return SWIG_Python_InitShadowInstance(args);
24116 }
24117
24118 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj = 0;
24120 int arg1 = (int) 0 ;
24121 wxInitDialogEvent *result = 0 ;
24122 int val1 ;
24123 int ecode1 = 0 ;
24124 PyObject * obj0 = 0 ;
24125 char * kwnames[] = {
24126 (char *) "Id", NULL
24127 };
24128
24129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24130 if (obj0) {
24131 ecode1 = SWIG_AsVal_int(obj0, &val1);
24132 if (!SWIG_IsOK(ecode1)) {
24133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24134 }
24135 arg1 = static_cast< int >(val1);
24136 }
24137 {
24138 PyThreadState* __tstate = wxPyBeginAllowThreads();
24139 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24140 wxPyEndAllowThreads(__tstate);
24141 if (PyErr_Occurred()) SWIG_fail;
24142 }
24143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24144 return resultobj;
24145 fail:
24146 return NULL;
24147 }
24148
24149
24150 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24151 PyObject *obj;
24152 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24153 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24154 return SWIG_Py_Void();
24155 }
24156
24157 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 return SWIG_Python_InitShadowInstance(args);
24159 }
24160
24161 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24162 PyObject *resultobj = 0;
24163 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24164 int arg2 = (int) 0 ;
24165 wxMenu *arg3 = (wxMenu *) NULL ;
24166 wxMenuEvent *result = 0 ;
24167 int val1 ;
24168 int ecode1 = 0 ;
24169 int val2 ;
24170 int ecode2 = 0 ;
24171 void *argp3 = 0 ;
24172 int res3 = 0 ;
24173 PyObject * obj0 = 0 ;
24174 PyObject * obj1 = 0 ;
24175 PyObject * obj2 = 0 ;
24176 char * kwnames[] = {
24177 (char *) "type",(char *) "winid",(char *) "menu", NULL
24178 };
24179
24180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24181 if (obj0) {
24182 ecode1 = SWIG_AsVal_int(obj0, &val1);
24183 if (!SWIG_IsOK(ecode1)) {
24184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24185 }
24186 arg1 = static_cast< wxEventType >(val1);
24187 }
24188 if (obj1) {
24189 ecode2 = SWIG_AsVal_int(obj1, &val2);
24190 if (!SWIG_IsOK(ecode2)) {
24191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24192 }
24193 arg2 = static_cast< int >(val2);
24194 }
24195 if (obj2) {
24196 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24197 if (!SWIG_IsOK(res3)) {
24198 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24199 }
24200 arg3 = reinterpret_cast< wxMenu * >(argp3);
24201 }
24202 {
24203 PyThreadState* __tstate = wxPyBeginAllowThreads();
24204 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24205 wxPyEndAllowThreads(__tstate);
24206 if (PyErr_Occurred()) SWIG_fail;
24207 }
24208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24218 int result;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 PyObject *swig_obj[1] ;
24222
24223 if (!args) SWIG_fail;
24224 swig_obj[0] = args;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 resultobj = SWIG_From_int(static_cast< int >(result));
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24244 PyObject *resultobj = 0;
24245 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24246 bool result;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 PyObject *swig_obj[1] ;
24250
24251 if (!args) SWIG_fail;
24252 swig_obj[0] = args;
24253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24254 if (!SWIG_IsOK(res1)) {
24255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24256 }
24257 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 {
24265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24266 }
24267 return resultobj;
24268 fail:
24269 return NULL;
24270 }
24271
24272
24273 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24274 PyObject *resultobj = 0;
24275 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24276 wxMenu *result = 0 ;
24277 void *argp1 = 0 ;
24278 int res1 = 0 ;
24279 PyObject *swig_obj[1] ;
24280
24281 if (!args) SWIG_fail;
24282 swig_obj[0] = args;
24283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24284 if (!SWIG_IsOK(res1)) {
24285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24286 }
24287 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24288 {
24289 PyThreadState* __tstate = wxPyBeginAllowThreads();
24290 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24291 wxPyEndAllowThreads(__tstate);
24292 if (PyErr_Occurred()) SWIG_fail;
24293 }
24294 {
24295 resultobj = wxPyMake_wxObject(result, (bool)0);
24296 }
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 PyObject *obj;
24305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24306 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24307 return SWIG_Py_Void();
24308 }
24309
24310 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 return SWIG_Python_InitShadowInstance(args);
24312 }
24313
24314 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24315 PyObject *resultobj = 0;
24316 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24317 int arg2 = (int) 0 ;
24318 wxCloseEvent *result = 0 ;
24319 int val1 ;
24320 int ecode1 = 0 ;
24321 int val2 ;
24322 int ecode2 = 0 ;
24323 PyObject * obj0 = 0 ;
24324 PyObject * obj1 = 0 ;
24325 char * kwnames[] = {
24326 (char *) "type",(char *) "winid", NULL
24327 };
24328
24329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24330 if (obj0) {
24331 ecode1 = SWIG_AsVal_int(obj0, &val1);
24332 if (!SWIG_IsOK(ecode1)) {
24333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24334 }
24335 arg1 = static_cast< wxEventType >(val1);
24336 }
24337 if (obj1) {
24338 ecode2 = SWIG_AsVal_int(obj1, &val2);
24339 if (!SWIG_IsOK(ecode2)) {
24340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24341 }
24342 arg2 = static_cast< int >(val2);
24343 }
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24347 wxPyEndAllowThreads(__tstate);
24348 if (PyErr_Occurred()) SWIG_fail;
24349 }
24350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24351 return resultobj;
24352 fail:
24353 return NULL;
24354 }
24355
24356
24357 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24358 PyObject *resultobj = 0;
24359 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24360 bool arg2 ;
24361 void *argp1 = 0 ;
24362 int res1 = 0 ;
24363 bool val2 ;
24364 int ecode2 = 0 ;
24365 PyObject * obj0 = 0 ;
24366 PyObject * obj1 = 0 ;
24367 char * kwnames[] = {
24368 (char *) "self",(char *) "logOff", NULL
24369 };
24370
24371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24373 if (!SWIG_IsOK(res1)) {
24374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24375 }
24376 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24377 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24378 if (!SWIG_IsOK(ecode2)) {
24379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24380 }
24381 arg2 = static_cast< bool >(val2);
24382 {
24383 PyThreadState* __tstate = wxPyBeginAllowThreads();
24384 (arg1)->SetLoggingOff(arg2);
24385 wxPyEndAllowThreads(__tstate);
24386 if (PyErr_Occurred()) SWIG_fail;
24387 }
24388 resultobj = SWIG_Py_Void();
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24396 PyObject *resultobj = 0;
24397 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24398 bool result;
24399 void *argp1 = 0 ;
24400 int res1 = 0 ;
24401 PyObject *swig_obj[1] ;
24402
24403 if (!args) SWIG_fail;
24404 swig_obj[0] = args;
24405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24406 if (!SWIG_IsOK(res1)) {
24407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24408 }
24409 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 {
24417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24418 }
24419 return resultobj;
24420 fail:
24421 return NULL;
24422 }
24423
24424
24425 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24426 PyObject *resultobj = 0;
24427 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24428 bool arg2 = (bool) true ;
24429 void *argp1 = 0 ;
24430 int res1 = 0 ;
24431 bool val2 ;
24432 int ecode2 = 0 ;
24433 PyObject * obj0 = 0 ;
24434 PyObject * obj1 = 0 ;
24435 char * kwnames[] = {
24436 (char *) "self",(char *) "veto", NULL
24437 };
24438
24439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24443 }
24444 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24445 if (obj1) {
24446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24447 if (!SWIG_IsOK(ecode2)) {
24448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24449 }
24450 arg2 = static_cast< bool >(val2);
24451 }
24452 {
24453 PyThreadState* __tstate = wxPyBeginAllowThreads();
24454 (arg1)->Veto(arg2);
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 resultobj = SWIG_Py_Void();
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24466 PyObject *resultobj = 0;
24467 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24468 bool result;
24469 void *argp1 = 0 ;
24470 int res1 = 0 ;
24471 PyObject *swig_obj[1] ;
24472
24473 if (!args) SWIG_fail;
24474 swig_obj[0] = args;
24475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24476 if (!SWIG_IsOK(res1)) {
24477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24478 }
24479 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24480 {
24481 PyThreadState* __tstate = wxPyBeginAllowThreads();
24482 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24483 wxPyEndAllowThreads(__tstate);
24484 if (PyErr_Occurred()) SWIG_fail;
24485 }
24486 {
24487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24488 }
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj = 0;
24497 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24498 bool arg2 ;
24499 void *argp1 = 0 ;
24500 int res1 = 0 ;
24501 bool val2 ;
24502 int ecode2 = 0 ;
24503 PyObject * obj0 = 0 ;
24504 PyObject * obj1 = 0 ;
24505 char * kwnames[] = {
24506 (char *) "self",(char *) "canVeto", NULL
24507 };
24508
24509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24513 }
24514 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24515 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24516 if (!SWIG_IsOK(ecode2)) {
24517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24518 }
24519 arg2 = static_cast< bool >(val2);
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 (arg1)->SetCanVeto(arg2);
24523 wxPyEndAllowThreads(__tstate);
24524 if (PyErr_Occurred()) SWIG_fail;
24525 }
24526 resultobj = SWIG_Py_Void();
24527 return resultobj;
24528 fail:
24529 return NULL;
24530 }
24531
24532
24533 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24534 PyObject *resultobj = 0;
24535 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24536 bool result;
24537 void *argp1 = 0 ;
24538 int res1 = 0 ;
24539 PyObject *swig_obj[1] ;
24540
24541 if (!args) SWIG_fail;
24542 swig_obj[0] = args;
24543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24544 if (!SWIG_IsOK(res1)) {
24545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24546 }
24547 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24551 wxPyEndAllowThreads(__tstate);
24552 if (PyErr_Occurred()) SWIG_fail;
24553 }
24554 {
24555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24556 }
24557 return resultobj;
24558 fail:
24559 return NULL;
24560 }
24561
24562
24563 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24564 PyObject *obj;
24565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24566 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24567 return SWIG_Py_Void();
24568 }
24569
24570 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571 return SWIG_Python_InitShadowInstance(args);
24572 }
24573
24574 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj = 0;
24576 int arg1 = (int) 0 ;
24577 bool arg2 = (bool) false ;
24578 wxShowEvent *result = 0 ;
24579 int val1 ;
24580 int ecode1 = 0 ;
24581 bool val2 ;
24582 int ecode2 = 0 ;
24583 PyObject * obj0 = 0 ;
24584 PyObject * obj1 = 0 ;
24585 char * kwnames[] = {
24586 (char *) "winid",(char *) "show", NULL
24587 };
24588
24589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24590 if (obj0) {
24591 ecode1 = SWIG_AsVal_int(obj0, &val1);
24592 if (!SWIG_IsOK(ecode1)) {
24593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24594 }
24595 arg1 = static_cast< int >(val1);
24596 }
24597 if (obj1) {
24598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24599 if (!SWIG_IsOK(ecode2)) {
24600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24601 }
24602 arg2 = static_cast< bool >(val2);
24603 }
24604 {
24605 PyThreadState* __tstate = wxPyBeginAllowThreads();
24606 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24607 wxPyEndAllowThreads(__tstate);
24608 if (PyErr_Occurred()) SWIG_fail;
24609 }
24610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24611 return resultobj;
24612 fail:
24613 return NULL;
24614 }
24615
24616
24617 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24618 PyObject *resultobj = 0;
24619 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24620 bool arg2 ;
24621 void *argp1 = 0 ;
24622 int res1 = 0 ;
24623 bool val2 ;
24624 int ecode2 = 0 ;
24625 PyObject * obj0 = 0 ;
24626 PyObject * obj1 = 0 ;
24627 char * kwnames[] = {
24628 (char *) "self",(char *) "show", NULL
24629 };
24630
24631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24633 if (!SWIG_IsOK(res1)) {
24634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24635 }
24636 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24637 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24638 if (!SWIG_IsOK(ecode2)) {
24639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24640 }
24641 arg2 = static_cast< bool >(val2);
24642 {
24643 PyThreadState* __tstate = wxPyBeginAllowThreads();
24644 (arg1)->SetShow(arg2);
24645 wxPyEndAllowThreads(__tstate);
24646 if (PyErr_Occurred()) SWIG_fail;
24647 }
24648 resultobj = SWIG_Py_Void();
24649 return resultobj;
24650 fail:
24651 return NULL;
24652 }
24653
24654
24655 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24656 PyObject *resultobj = 0;
24657 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24658 bool result;
24659 void *argp1 = 0 ;
24660 int res1 = 0 ;
24661 PyObject *swig_obj[1] ;
24662
24663 if (!args) SWIG_fail;
24664 swig_obj[0] = args;
24665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24666 if (!SWIG_IsOK(res1)) {
24667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24668 }
24669 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 {
24677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24678 }
24679 return resultobj;
24680 fail:
24681 return NULL;
24682 }
24683
24684
24685 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24686 PyObject *obj;
24687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24688 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24689 return SWIG_Py_Void();
24690 }
24691
24692 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 return SWIG_Python_InitShadowInstance(args);
24694 }
24695
24696 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj = 0;
24698 int arg1 = (int) 0 ;
24699 bool arg2 = (bool) true ;
24700 wxIconizeEvent *result = 0 ;
24701 int val1 ;
24702 int ecode1 = 0 ;
24703 bool val2 ;
24704 int ecode2 = 0 ;
24705 PyObject * obj0 = 0 ;
24706 PyObject * obj1 = 0 ;
24707 char * kwnames[] = {
24708 (char *) "id",(char *) "iconized", NULL
24709 };
24710
24711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24712 if (obj0) {
24713 ecode1 = SWIG_AsVal_int(obj0, &val1);
24714 if (!SWIG_IsOK(ecode1)) {
24715 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24716 }
24717 arg1 = static_cast< int >(val1);
24718 }
24719 if (obj1) {
24720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24721 if (!SWIG_IsOK(ecode2)) {
24722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24723 }
24724 arg2 = static_cast< bool >(val2);
24725 }
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24742 bool result;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24752 }
24753 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (bool)(arg1)->Iconized();
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 {
24761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24762 }
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 PyObject *obj;
24771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24772 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24773 return SWIG_Py_Void();
24774 }
24775
24776 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24777 return SWIG_Python_InitShadowInstance(args);
24778 }
24779
24780 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24781 PyObject *resultobj = 0;
24782 int arg1 = (int) 0 ;
24783 wxMaximizeEvent *result = 0 ;
24784 int val1 ;
24785 int ecode1 = 0 ;
24786 PyObject * obj0 = 0 ;
24787 char * kwnames[] = {
24788 (char *) "id", NULL
24789 };
24790
24791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24792 if (obj0) {
24793 ecode1 = SWIG_AsVal_int(obj0, &val1);
24794 if (!SWIG_IsOK(ecode1)) {
24795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24796 }
24797 arg1 = static_cast< int >(val1);
24798 }
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24813 PyObject *obj;
24814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24815 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24816 return SWIG_Py_Void();
24817 }
24818
24819 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 return SWIG_Python_InitShadowInstance(args);
24821 }
24822
24823 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24824 PyObject *resultobj = 0;
24825 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24826 wxPoint result;
24827 void *argp1 = 0 ;
24828 int res1 = 0 ;
24829 PyObject *swig_obj[1] ;
24830
24831 if (!args) SWIG_fail;
24832 swig_obj[0] = args;
24833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24834 if (!SWIG_IsOK(res1)) {
24835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24836 }
24837 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24838 {
24839 PyThreadState* __tstate = wxPyBeginAllowThreads();
24840 result = (arg1)->GetPosition();
24841 wxPyEndAllowThreads(__tstate);
24842 if (PyErr_Occurred()) SWIG_fail;
24843 }
24844 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24852 PyObject *resultobj = 0;
24853 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24854 int result;
24855 void *argp1 = 0 ;
24856 int res1 = 0 ;
24857 PyObject *swig_obj[1] ;
24858
24859 if (!args) SWIG_fail;
24860 swig_obj[0] = args;
24861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24862 if (!SWIG_IsOK(res1)) {
24863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24864 }
24865 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (int)(arg1)->GetNumberOfFiles();
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 resultobj = SWIG_From_int(static_cast< int >(result));
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *resultobj = 0;
24881 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24882 PyObject *result = 0 ;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 PyObject *swig_obj[1] ;
24886
24887 if (!args) SWIG_fail;
24888 swig_obj[0] = args;
24889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24890 if (!SWIG_IsOK(res1)) {
24891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24892 }
24893 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24894 {
24895 PyThreadState* __tstate = wxPyBeginAllowThreads();
24896 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24897 wxPyEndAllowThreads(__tstate);
24898 if (PyErr_Occurred()) SWIG_fail;
24899 }
24900 resultobj = result;
24901 return resultobj;
24902 fail:
24903 return NULL;
24904 }
24905
24906
24907 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24908 PyObject *obj;
24909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24910 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24911 return SWIG_Py_Void();
24912 }
24913
24914 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj = 0;
24916 int arg1 = (int) 0 ;
24917 wxUpdateUIEvent *result = 0 ;
24918 int val1 ;
24919 int ecode1 = 0 ;
24920 PyObject * obj0 = 0 ;
24921 char * kwnames[] = {
24922 (char *) "commandId", NULL
24923 };
24924
24925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24926 if (obj0) {
24927 ecode1 = SWIG_AsVal_int(obj0, &val1);
24928 if (!SWIG_IsOK(ecode1)) {
24929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24930 }
24931 arg1 = static_cast< int >(val1);
24932 }
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24949 bool result;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 PyObject *swig_obj[1] ;
24953
24954 if (!args) SWIG_fail;
24955 swig_obj[0] = args;
24956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24959 }
24960 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 {
24968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24969 }
24970 return resultobj;
24971 fail:
24972 return NULL;
24973 }
24974
24975
24976 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24977 PyObject *resultobj = 0;
24978 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24979 bool result;
24980 void *argp1 = 0 ;
24981 int res1 = 0 ;
24982 PyObject *swig_obj[1] ;
24983
24984 if (!args) SWIG_fail;
24985 swig_obj[0] = args;
24986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24987 if (!SWIG_IsOK(res1)) {
24988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24989 }
24990 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24991 {
24992 PyThreadState* __tstate = wxPyBeginAllowThreads();
24993 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 {
24998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24999 }
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25007 PyObject *resultobj = 0;
25008 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25009 bool result;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 PyObject *swig_obj[1] ;
25013
25014 if (!args) SWIG_fail;
25015 swig_obj[0] = args;
25016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25017 if (!SWIG_IsOK(res1)) {
25018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25019 }
25020 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25024 wxPyEndAllowThreads(__tstate);
25025 if (PyErr_Occurred()) SWIG_fail;
25026 }
25027 {
25028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25029 }
25030 return resultobj;
25031 fail:
25032 return NULL;
25033 }
25034
25035
25036 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25037 PyObject *resultobj = 0;
25038 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25039 wxString result;
25040 void *argp1 = 0 ;
25041 int res1 = 0 ;
25042 PyObject *swig_obj[1] ;
25043
25044 if (!args) SWIG_fail;
25045 swig_obj[0] = args;
25046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25047 if (!SWIG_IsOK(res1)) {
25048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25049 }
25050 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25051 {
25052 PyThreadState* __tstate = wxPyBeginAllowThreads();
25053 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25054 wxPyEndAllowThreads(__tstate);
25055 if (PyErr_Occurred()) SWIG_fail;
25056 }
25057 {
25058 #if wxUSE_UNICODE
25059 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25060 #else
25061 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25062 #endif
25063 }
25064 return resultobj;
25065 fail:
25066 return NULL;
25067 }
25068
25069
25070 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25071 PyObject *resultobj = 0;
25072 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25073 bool result;
25074 void *argp1 = 0 ;
25075 int res1 = 0 ;
25076 PyObject *swig_obj[1] ;
25077
25078 if (!args) SWIG_fail;
25079 swig_obj[0] = args;
25080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25081 if (!SWIG_IsOK(res1)) {
25082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25083 }
25084 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 {
25092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25093 }
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25101 PyObject *resultobj = 0;
25102 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25103 bool result;
25104 void *argp1 = 0 ;
25105 int res1 = 0 ;
25106 PyObject *swig_obj[1] ;
25107
25108 if (!args) SWIG_fail;
25109 swig_obj[0] = args;
25110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25111 if (!SWIG_IsOK(res1)) {
25112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25113 }
25114 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 {
25122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25123 }
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131 PyObject *resultobj = 0;
25132 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25133 bool result;
25134 void *argp1 = 0 ;
25135 int res1 = 0 ;
25136 PyObject *swig_obj[1] ;
25137
25138 if (!args) SWIG_fail;
25139 swig_obj[0] = args;
25140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25141 if (!SWIG_IsOK(res1)) {
25142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25143 }
25144 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25145 {
25146 PyThreadState* __tstate = wxPyBeginAllowThreads();
25147 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25148 wxPyEndAllowThreads(__tstate);
25149 if (PyErr_Occurred()) SWIG_fail;
25150 }
25151 {
25152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25153 }
25154 return resultobj;
25155 fail:
25156 return NULL;
25157 }
25158
25159
25160 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25161 PyObject *resultobj = 0;
25162 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25163 bool result;
25164 void *argp1 = 0 ;
25165 int res1 = 0 ;
25166 PyObject *swig_obj[1] ;
25167
25168 if (!args) SWIG_fail;
25169 swig_obj[0] = args;
25170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25171 if (!SWIG_IsOK(res1)) {
25172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25173 }
25174 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25175 {
25176 PyThreadState* __tstate = wxPyBeginAllowThreads();
25177 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25183 }
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25191 PyObject *resultobj = 0;
25192 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25193 bool arg2 ;
25194 void *argp1 = 0 ;
25195 int res1 = 0 ;
25196 bool val2 ;
25197 int ecode2 = 0 ;
25198 PyObject * obj0 = 0 ;
25199 PyObject * obj1 = 0 ;
25200 char * kwnames[] = {
25201 (char *) "self",(char *) "check", NULL
25202 };
25203
25204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25206 if (!SWIG_IsOK(res1)) {
25207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25208 }
25209 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25210 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25211 if (!SWIG_IsOK(ecode2)) {
25212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25213 }
25214 arg2 = static_cast< bool >(val2);
25215 {
25216 PyThreadState* __tstate = wxPyBeginAllowThreads();
25217 (arg1)->Check(arg2);
25218 wxPyEndAllowThreads(__tstate);
25219 if (PyErr_Occurred()) SWIG_fail;
25220 }
25221 resultobj = SWIG_Py_Void();
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj = 0;
25230 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25231 bool arg2 ;
25232 void *argp1 = 0 ;
25233 int res1 = 0 ;
25234 bool val2 ;
25235 int ecode2 = 0 ;
25236 PyObject * obj0 = 0 ;
25237 PyObject * obj1 = 0 ;
25238 char * kwnames[] = {
25239 (char *) "self",(char *) "enable", NULL
25240 };
25241
25242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25244 if (!SWIG_IsOK(res1)) {
25245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25246 }
25247 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25249 if (!SWIG_IsOK(ecode2)) {
25250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25251 }
25252 arg2 = static_cast< bool >(val2);
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 (arg1)->Enable(arg2);
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 resultobj = SWIG_Py_Void();
25260 return resultobj;
25261 fail:
25262 return NULL;
25263 }
25264
25265
25266 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25269 bool arg2 ;
25270 void *argp1 = 0 ;
25271 int res1 = 0 ;
25272 bool val2 ;
25273 int ecode2 = 0 ;
25274 PyObject * obj0 = 0 ;
25275 PyObject * obj1 = 0 ;
25276 char * kwnames[] = {
25277 (char *) "self",(char *) "show", NULL
25278 };
25279
25280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25282 if (!SWIG_IsOK(res1)) {
25283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25284 }
25285 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25286 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25287 if (!SWIG_IsOK(ecode2)) {
25288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25289 }
25290 arg2 = static_cast< bool >(val2);
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 (arg1)->Show(arg2);
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 resultobj = SWIG_Py_Void();
25298 return resultobj;
25299 fail:
25300 return NULL;
25301 }
25302
25303
25304 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25305 PyObject *resultobj = 0;
25306 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25307 wxString *arg2 = 0 ;
25308 void *argp1 = 0 ;
25309 int res1 = 0 ;
25310 bool temp2 = false ;
25311 PyObject * obj0 = 0 ;
25312 PyObject * obj1 = 0 ;
25313 char * kwnames[] = {
25314 (char *) "self",(char *) "text", NULL
25315 };
25316
25317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25321 }
25322 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25323 {
25324 arg2 = wxString_in_helper(obj1);
25325 if (arg2 == NULL) SWIG_fail;
25326 temp2 = true;
25327 }
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 (arg1)->SetText((wxString const &)*arg2);
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 resultobj = SWIG_Py_Void();
25335 {
25336 if (temp2)
25337 delete arg2;
25338 }
25339 return resultobj;
25340 fail:
25341 {
25342 if (temp2)
25343 delete arg2;
25344 }
25345 return NULL;
25346 }
25347
25348
25349 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 long arg1 ;
25352 long val1 ;
25353 int ecode1 = 0 ;
25354 PyObject * obj0 = 0 ;
25355 char * kwnames[] = {
25356 (char *) "updateInterval", NULL
25357 };
25358
25359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25360 ecode1 = SWIG_AsVal_long(obj0, &val1);
25361 if (!SWIG_IsOK(ecode1)) {
25362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25363 }
25364 arg1 = static_cast< long >(val1);
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 wxUpdateUIEvent::SetUpdateInterval(arg1);
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 resultobj = SWIG_Py_Void();
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 PyObject *resultobj = 0;
25380 long result;
25381
25382 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_From_long(static_cast< long >(result));
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj = 0;
25398 wxWindow *arg1 = (wxWindow *) 0 ;
25399 bool result;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 PyObject * obj0 = 0 ;
25403 char * kwnames[] = {
25404 (char *) "win", NULL
25405 };
25406
25407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25409 if (!SWIG_IsOK(res1)) {
25410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25411 }
25412 arg1 = reinterpret_cast< wxWindow * >(argp1);
25413 {
25414 PyThreadState* __tstate = wxPyBeginAllowThreads();
25415 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25416 wxPyEndAllowThreads(__tstate);
25417 if (PyErr_Occurred()) SWIG_fail;
25418 }
25419 {
25420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25421 }
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25429 PyObject *resultobj = 0;
25430
25431 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 wxUpdateUIEvent::ResetUpdateTime();
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_Py_Void();
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25446 PyObject *resultobj = 0;
25447 wxUpdateUIMode arg1 ;
25448 int val1 ;
25449 int ecode1 = 0 ;
25450 PyObject * obj0 = 0 ;
25451 char * kwnames[] = {
25452 (char *) "mode", NULL
25453 };
25454
25455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25456 ecode1 = SWIG_AsVal_int(obj0, &val1);
25457 if (!SWIG_IsOK(ecode1)) {
25458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25459 }
25460 arg1 = static_cast< wxUpdateUIMode >(val1);
25461 {
25462 PyThreadState* __tstate = wxPyBeginAllowThreads();
25463 wxUpdateUIEvent::SetMode(arg1);
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 resultobj = SWIG_Py_Void();
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475 PyObject *resultobj = 0;
25476 wxUpdateUIMode result;
25477
25478 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25479 {
25480 PyThreadState* __tstate = wxPyBeginAllowThreads();
25481 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25482 wxPyEndAllowThreads(__tstate);
25483 if (PyErr_Occurred()) SWIG_fail;
25484 }
25485 resultobj = SWIG_From_int(static_cast< int >(result));
25486 return resultobj;
25487 fail:
25488 return NULL;
25489 }
25490
25491
25492 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25493 PyObject *obj;
25494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25495 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25496 return SWIG_Py_Void();
25497 }
25498
25499 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25500 return SWIG_Python_InitShadowInstance(args);
25501 }
25502
25503 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25504 PyObject *resultobj = 0;
25505 wxSysColourChangedEvent *result = 0 ;
25506
25507 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25522 PyObject *obj;
25523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25524 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25525 return SWIG_Py_Void();
25526 }
25527
25528 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 return SWIG_Python_InitShadowInstance(args);
25530 }
25531
25532 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25533 PyObject *resultobj = 0;
25534 int arg1 = (int) 0 ;
25535 wxWindow *arg2 = (wxWindow *) NULL ;
25536 wxMouseCaptureChangedEvent *result = 0 ;
25537 int val1 ;
25538 int ecode1 = 0 ;
25539 void *argp2 = 0 ;
25540 int res2 = 0 ;
25541 PyObject * obj0 = 0 ;
25542 PyObject * obj1 = 0 ;
25543 char * kwnames[] = {
25544 (char *) "winid",(char *) "gainedCapture", NULL
25545 };
25546
25547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25548 if (obj0) {
25549 ecode1 = SWIG_AsVal_int(obj0, &val1);
25550 if (!SWIG_IsOK(ecode1)) {
25551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25552 }
25553 arg1 = static_cast< int >(val1);
25554 }
25555 if (obj1) {
25556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25557 if (!SWIG_IsOK(res2)) {
25558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25559 }
25560 arg2 = reinterpret_cast< wxWindow * >(argp2);
25561 }
25562 {
25563 PyThreadState* __tstate = wxPyBeginAllowThreads();
25564 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25576 PyObject *resultobj = 0;
25577 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25578 wxWindow *result = 0 ;
25579 void *argp1 = 0 ;
25580 int res1 = 0 ;
25581 PyObject *swig_obj[1] ;
25582
25583 if (!args) SWIG_fail;
25584 swig_obj[0] = args;
25585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25586 if (!SWIG_IsOK(res1)) {
25587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25588 }
25589 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25590 {
25591 PyThreadState* __tstate = wxPyBeginAllowThreads();
25592 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25593 wxPyEndAllowThreads(__tstate);
25594 if (PyErr_Occurred()) SWIG_fail;
25595 }
25596 {
25597 resultobj = wxPyMake_wxObject(result, (bool)0);
25598 }
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *obj;
25607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25608 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25609 return SWIG_Py_Void();
25610 }
25611
25612 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25613 return SWIG_Python_InitShadowInstance(args);
25614 }
25615
25616 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj = 0;
25618 int arg1 = (int) 0 ;
25619 wxMouseCaptureLostEvent *result = 0 ;
25620 int val1 ;
25621 int ecode1 = 0 ;
25622 PyObject * obj0 = 0 ;
25623 char * kwnames[] = {
25624 (char *) "winid", NULL
25625 };
25626
25627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25628 if (obj0) {
25629 ecode1 = SWIG_AsVal_int(obj0, &val1);
25630 if (!SWIG_IsOK(ecode1)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25632 }
25633 arg1 = static_cast< int >(val1);
25634 }
25635 {
25636 PyThreadState* __tstate = wxPyBeginAllowThreads();
25637 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 PyObject *obj;
25650 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25651 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25652 return SWIG_Py_Void();
25653 }
25654
25655 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656 return SWIG_Python_InitShadowInstance(args);
25657 }
25658
25659 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxDisplayChangedEvent *result = 0 ;
25662
25663 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25664 {
25665 PyThreadState* __tstate = wxPyBeginAllowThreads();
25666 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25667 wxPyEndAllowThreads(__tstate);
25668 if (PyErr_Occurred()) SWIG_fail;
25669 }
25670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25678 PyObject *obj;
25679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25680 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25681 return SWIG_Py_Void();
25682 }
25683
25684 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 return SWIG_Python_InitShadowInstance(args);
25686 }
25687
25688 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj = 0;
25690 int arg1 = (int) 0 ;
25691 wxPaletteChangedEvent *result = 0 ;
25692 int val1 ;
25693 int ecode1 = 0 ;
25694 PyObject * obj0 = 0 ;
25695 char * kwnames[] = {
25696 (char *) "id", NULL
25697 };
25698
25699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25700 if (obj0) {
25701 ecode1 = SWIG_AsVal_int(obj0, &val1);
25702 if (!SWIG_IsOK(ecode1)) {
25703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25704 }
25705 arg1 = static_cast< int >(val1);
25706 }
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25710 wxPyEndAllowThreads(__tstate);
25711 if (PyErr_Occurred()) SWIG_fail;
25712 }
25713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25721 PyObject *resultobj = 0;
25722 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25723 wxWindow *arg2 = (wxWindow *) 0 ;
25724 void *argp1 = 0 ;
25725 int res1 = 0 ;
25726 void *argp2 = 0 ;
25727 int res2 = 0 ;
25728 PyObject * obj0 = 0 ;
25729 PyObject * obj1 = 0 ;
25730 char * kwnames[] = {
25731 (char *) "self",(char *) "win", NULL
25732 };
25733
25734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25736 if (!SWIG_IsOK(res1)) {
25737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25738 }
25739 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25740 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25741 if (!SWIG_IsOK(res2)) {
25742 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25743 }
25744 arg2 = reinterpret_cast< wxWindow * >(argp2);
25745 {
25746 PyThreadState* __tstate = wxPyBeginAllowThreads();
25747 (arg1)->SetChangedWindow(arg2);
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 resultobj = SWIG_Py_Void();
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25759 PyObject *resultobj = 0;
25760 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25761 wxWindow *result = 0 ;
25762 void *argp1 = 0 ;
25763 int res1 = 0 ;
25764 PyObject *swig_obj[1] ;
25765
25766 if (!args) SWIG_fail;
25767 swig_obj[0] = args;
25768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25769 if (!SWIG_IsOK(res1)) {
25770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25771 }
25772 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25773 {
25774 PyThreadState* __tstate = wxPyBeginAllowThreads();
25775 result = (wxWindow *)(arg1)->GetChangedWindow();
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 {
25780 resultobj = wxPyMake_wxObject(result, (bool)0);
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25789 PyObject *obj;
25790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25791 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25792 return SWIG_Py_Void();
25793 }
25794
25795 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25796 return SWIG_Python_InitShadowInstance(args);
25797 }
25798
25799 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj = 0;
25801 int arg1 = (int) 0 ;
25802 wxQueryNewPaletteEvent *result = 0 ;
25803 int val1 ;
25804 int ecode1 = 0 ;
25805 PyObject * obj0 = 0 ;
25806 char * kwnames[] = {
25807 (char *) "winid", NULL
25808 };
25809
25810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25811 if (obj0) {
25812 ecode1 = SWIG_AsVal_int(obj0, &val1);
25813 if (!SWIG_IsOK(ecode1)) {
25814 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25815 }
25816 arg1 = static_cast< int >(val1);
25817 }
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25821 wxPyEndAllowThreads(__tstate);
25822 if (PyErr_Occurred()) SWIG_fail;
25823 }
25824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25825 return resultobj;
25826 fail:
25827 return NULL;
25828 }
25829
25830
25831 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25832 PyObject *resultobj = 0;
25833 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25834 bool arg2 ;
25835 void *argp1 = 0 ;
25836 int res1 = 0 ;
25837 bool val2 ;
25838 int ecode2 = 0 ;
25839 PyObject * obj0 = 0 ;
25840 PyObject * obj1 = 0 ;
25841 char * kwnames[] = {
25842 (char *) "self",(char *) "realized", NULL
25843 };
25844
25845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25847 if (!SWIG_IsOK(res1)) {
25848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25849 }
25850 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25851 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25852 if (!SWIG_IsOK(ecode2)) {
25853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25854 }
25855 arg2 = static_cast< bool >(val2);
25856 {
25857 PyThreadState* __tstate = wxPyBeginAllowThreads();
25858 (arg1)->SetPaletteRealized(arg2);
25859 wxPyEndAllowThreads(__tstate);
25860 if (PyErr_Occurred()) SWIG_fail;
25861 }
25862 resultobj = SWIG_Py_Void();
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25870 PyObject *resultobj = 0;
25871 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25872 bool result;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 PyObject *swig_obj[1] ;
25876
25877 if (!args) SWIG_fail;
25878 swig_obj[0] = args;
25879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25880 if (!SWIG_IsOK(res1)) {
25881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25882 }
25883 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 {
25891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25892 }
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 SWIGINTERN PyObject *QueryNewPaletteEvent_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_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25903 return SWIG_Py_Void();
25904 }
25905
25906 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25907 return SWIG_Python_InitShadowInstance(args);
25908 }
25909
25910 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25911 PyObject *resultobj = 0;
25912 wxNavigationKeyEvent *result = 0 ;
25913
25914 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25922 return resultobj;
25923 fail:
25924 return NULL;
25925 }
25926
25927
25928 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25929 PyObject *resultobj = 0;
25930 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25931 bool result;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 PyObject *swig_obj[1] ;
25935
25936 if (!args) SWIG_fail;
25937 swig_obj[0] = args;
25938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25941 }
25942 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 {
25950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25951 }
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = 0;
25960 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25961 bool arg2 ;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 bool val2 ;
25965 int ecode2 = 0 ;
25966 PyObject * obj0 = 0 ;
25967 PyObject * obj1 = 0 ;
25968 char * kwnames[] = {
25969 (char *) "self",(char *) "forward", NULL
25970 };
25971
25972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25974 if (!SWIG_IsOK(res1)) {
25975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25976 }
25977 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25978 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25979 if (!SWIG_IsOK(ecode2)) {
25980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25981 }
25982 arg2 = static_cast< bool >(val2);
25983 {
25984 PyThreadState* __tstate = wxPyBeginAllowThreads();
25985 (arg1)->SetDirection(arg2);
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 resultobj = SWIG_Py_Void();
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997 PyObject *resultobj = 0;
25998 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25999 bool result;
26000 void *argp1 = 0 ;
26001 int res1 = 0 ;
26002 PyObject *swig_obj[1] ;
26003
26004 if (!args) SWIG_fail;
26005 swig_obj[0] = args;
26006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26007 if (!SWIG_IsOK(res1)) {
26008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26009 }
26010 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 {
26018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26019 }
26020 return resultobj;
26021 fail:
26022 return NULL;
26023 }
26024
26025
26026 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26027 PyObject *resultobj = 0;
26028 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26029 bool arg2 ;
26030 void *argp1 = 0 ;
26031 int res1 = 0 ;
26032 bool val2 ;
26033 int ecode2 = 0 ;
26034 PyObject * obj0 = 0 ;
26035 PyObject * obj1 = 0 ;
26036 char * kwnames[] = {
26037 (char *) "self",(char *) "ischange", NULL
26038 };
26039
26040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26042 if (!SWIG_IsOK(res1)) {
26043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26044 }
26045 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26046 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26047 if (!SWIG_IsOK(ecode2)) {
26048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26049 }
26050 arg2 = static_cast< bool >(val2);
26051 {
26052 PyThreadState* __tstate = wxPyBeginAllowThreads();
26053 (arg1)->SetWindowChange(arg2);
26054 wxPyEndAllowThreads(__tstate);
26055 if (PyErr_Occurred()) SWIG_fail;
26056 }
26057 resultobj = SWIG_Py_Void();
26058 return resultobj;
26059 fail:
26060 return NULL;
26061 }
26062
26063
26064 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26065 PyObject *resultobj = 0;
26066 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26067 bool result;
26068 void *argp1 = 0 ;
26069 int res1 = 0 ;
26070 PyObject *swig_obj[1] ;
26071
26072 if (!args) SWIG_fail;
26073 swig_obj[0] = args;
26074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26075 if (!SWIG_IsOK(res1)) {
26076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26077 }
26078 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26079 {
26080 PyThreadState* __tstate = wxPyBeginAllowThreads();
26081 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 {
26086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26087 }
26088 return resultobj;
26089 fail:
26090 return NULL;
26091 }
26092
26093
26094 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26095 PyObject *resultobj = 0;
26096 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26097 bool arg2 ;
26098 void *argp1 = 0 ;
26099 int res1 = 0 ;
26100 bool val2 ;
26101 int ecode2 = 0 ;
26102 PyObject * obj0 = 0 ;
26103 PyObject * obj1 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "self",(char *) "bIs", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26110 if (!SWIG_IsOK(res1)) {
26111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26112 }
26113 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26114 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26115 if (!SWIG_IsOK(ecode2)) {
26116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26117 }
26118 arg2 = static_cast< bool >(val2);
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 (arg1)->SetFromTab(arg2);
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 resultobj = SWIG_Py_Void();
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj = 0;
26134 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26135 long arg2 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 long val2 ;
26139 int ecode2 = 0 ;
26140 PyObject * obj0 = 0 ;
26141 PyObject * obj1 = 0 ;
26142 char * kwnames[] = {
26143 (char *) "self",(char *) "flags", NULL
26144 };
26145
26146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26148 if (!SWIG_IsOK(res1)) {
26149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26150 }
26151 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26152 ecode2 = SWIG_AsVal_long(obj1, &val2);
26153 if (!SWIG_IsOK(ecode2)) {
26154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26155 }
26156 arg2 = static_cast< long >(val2);
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 (arg1)->SetFlags(arg2);
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_Py_Void();
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26171 PyObject *resultobj = 0;
26172 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26173 wxWindow *result = 0 ;
26174 void *argp1 = 0 ;
26175 int res1 = 0 ;
26176 PyObject *swig_obj[1] ;
26177
26178 if (!args) SWIG_fail;
26179 swig_obj[0] = args;
26180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26181 if (!SWIG_IsOK(res1)) {
26182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26183 }
26184 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26185 {
26186 PyThreadState* __tstate = wxPyBeginAllowThreads();
26187 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26188 wxPyEndAllowThreads(__tstate);
26189 if (PyErr_Occurred()) SWIG_fail;
26190 }
26191 {
26192 resultobj = wxPyMake_wxObject(result, (bool)0);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj = 0;
26202 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26203 wxWindow *arg2 = (wxWindow *) 0 ;
26204 void *argp1 = 0 ;
26205 int res1 = 0 ;
26206 void *argp2 = 0 ;
26207 int res2 = 0 ;
26208 PyObject * obj0 = 0 ;
26209 PyObject * obj1 = 0 ;
26210 char * kwnames[] = {
26211 (char *) "self",(char *) "win", NULL
26212 };
26213
26214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26216 if (!SWIG_IsOK(res1)) {
26217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26218 }
26219 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26221 if (!SWIG_IsOK(res2)) {
26222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26223 }
26224 arg2 = reinterpret_cast< wxWindow * >(argp2);
26225 {
26226 PyThreadState* __tstate = wxPyBeginAllowThreads();
26227 (arg1)->SetCurrentFocus(arg2);
26228 wxPyEndAllowThreads(__tstate);
26229 if (PyErr_Occurred()) SWIG_fail;
26230 }
26231 resultobj = SWIG_Py_Void();
26232 return resultobj;
26233 fail:
26234 return NULL;
26235 }
26236
26237
26238 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26239 PyObject *obj;
26240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26241 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26242 return SWIG_Py_Void();
26243 }
26244
26245 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 return SWIG_Python_InitShadowInstance(args);
26247 }
26248
26249 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj = 0;
26251 wxWindow *arg1 = (wxWindow *) NULL ;
26252 wxWindowCreateEvent *result = 0 ;
26253 void *argp1 = 0 ;
26254 int res1 = 0 ;
26255 PyObject * obj0 = 0 ;
26256 char * kwnames[] = {
26257 (char *) "win", NULL
26258 };
26259
26260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26261 if (obj0) {
26262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26263 if (!SWIG_IsOK(res1)) {
26264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26265 }
26266 arg1 = reinterpret_cast< wxWindow * >(argp1);
26267 }
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 PyObject *resultobj = 0;
26283 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26284 wxWindow *result = 0 ;
26285 void *argp1 = 0 ;
26286 int res1 = 0 ;
26287 PyObject *swig_obj[1] ;
26288
26289 if (!args) SWIG_fail;
26290 swig_obj[0] = args;
26291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26292 if (!SWIG_IsOK(res1)) {
26293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26294 }
26295 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26296 {
26297 PyThreadState* __tstate = wxPyBeginAllowThreads();
26298 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26299 wxPyEndAllowThreads(__tstate);
26300 if (PyErr_Occurred()) SWIG_fail;
26301 }
26302 {
26303 resultobj = wxPyMake_wxObject(result, (bool)0);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 PyObject *obj;
26313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26314 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26315 return SWIG_Py_Void();
26316 }
26317
26318 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26319 return SWIG_Python_InitShadowInstance(args);
26320 }
26321
26322 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = 0;
26324 wxWindow *arg1 = (wxWindow *) NULL ;
26325 wxWindowDestroyEvent *result = 0 ;
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:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26334 if (obj0) {
26335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26336 if (!SWIG_IsOK(res1)) {
26337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26338 }
26339 arg1 = reinterpret_cast< wxWindow * >(argp1);
26340 }
26341 {
26342 PyThreadState* __tstate = wxPyBeginAllowThreads();
26343 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26355 PyObject *resultobj = 0;
26356 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26357 wxWindow *result = 0 ;
26358 void *argp1 = 0 ;
26359 int res1 = 0 ;
26360 PyObject *swig_obj[1] ;
26361
26362 if (!args) SWIG_fail;
26363 swig_obj[0] = args;
26364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26365 if (!SWIG_IsOK(res1)) {
26366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26367 }
26368 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 {
26376 resultobj = wxPyMake_wxObject(result, (bool)0);
26377 }
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 PyObject *obj;
26386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26387 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26388 return SWIG_Py_Void();
26389 }
26390
26391 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26392 return SWIG_Python_InitShadowInstance(args);
26393 }
26394
26395 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26396 PyObject *resultobj = 0;
26397 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26398 int arg2 = (int) 0 ;
26399 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26400 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26401 wxContextMenuEvent *result = 0 ;
26402 int val1 ;
26403 int ecode1 = 0 ;
26404 int val2 ;
26405 int ecode2 = 0 ;
26406 wxPoint temp3 ;
26407 PyObject * obj0 = 0 ;
26408 PyObject * obj1 = 0 ;
26409 PyObject * obj2 = 0 ;
26410 char * kwnames[] = {
26411 (char *) "type",(char *) "winid",(char *) "pt", NULL
26412 };
26413
26414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26415 if (obj0) {
26416 ecode1 = SWIG_AsVal_int(obj0, &val1);
26417 if (!SWIG_IsOK(ecode1)) {
26418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26419 }
26420 arg1 = static_cast< wxEventType >(val1);
26421 }
26422 if (obj1) {
26423 ecode2 = SWIG_AsVal_int(obj1, &val2);
26424 if (!SWIG_IsOK(ecode2)) {
26425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26426 }
26427 arg2 = static_cast< int >(val2);
26428 }
26429 if (obj2) {
26430 {
26431 arg3 = &temp3;
26432 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26433 }
26434 }
26435 {
26436 PyThreadState* __tstate = wxPyBeginAllowThreads();
26437 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26449 PyObject *resultobj = 0;
26450 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26451 wxPoint *result = 0 ;
26452 void *argp1 = 0 ;
26453 int res1 = 0 ;
26454 PyObject *swig_obj[1] ;
26455
26456 if (!args) SWIG_fail;
26457 swig_obj[0] = args;
26458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26459 if (!SWIG_IsOK(res1)) {
26460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26461 }
26462 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26463 {
26464 PyThreadState* __tstate = wxPyBeginAllowThreads();
26465 {
26466 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26467 result = (wxPoint *) &_result_ref;
26468 }
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26473 return resultobj;
26474 fail:
26475 return NULL;
26476 }
26477
26478
26479 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26480 PyObject *resultobj = 0;
26481 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26482 wxPoint *arg2 = 0 ;
26483 void *argp1 = 0 ;
26484 int res1 = 0 ;
26485 wxPoint temp2 ;
26486 PyObject * obj0 = 0 ;
26487 PyObject * obj1 = 0 ;
26488 char * kwnames[] = {
26489 (char *) "self",(char *) "pos", NULL
26490 };
26491
26492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26494 if (!SWIG_IsOK(res1)) {
26495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26496 }
26497 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26498 {
26499 arg2 = &temp2;
26500 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26501 }
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 (arg1)->SetPosition((wxPoint const &)*arg2);
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_Py_Void();
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 PyObject *obj;
26517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26518 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26519 return SWIG_Py_Void();
26520 }
26521
26522 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 return SWIG_Python_InitShadowInstance(args);
26524 }
26525
26526 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26527 PyObject *resultobj = 0;
26528 wxIdleEvent *result = 0 ;
26529
26530 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = (wxIdleEvent *)new wxIdleEvent();
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = 0;
26546 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26547 bool arg2 = (bool) true ;
26548 void *argp1 = 0 ;
26549 int res1 = 0 ;
26550 bool val2 ;
26551 int ecode2 = 0 ;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554 char * kwnames[] = {
26555 (char *) "self",(char *) "needMore", NULL
26556 };
26557
26558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26560 if (!SWIG_IsOK(res1)) {
26561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26562 }
26563 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26564 if (obj1) {
26565 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26566 if (!SWIG_IsOK(ecode2)) {
26567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26568 }
26569 arg2 = static_cast< bool >(val2);
26570 }
26571 {
26572 PyThreadState* __tstate = wxPyBeginAllowThreads();
26573 (arg1)->RequestMore(arg2);
26574 wxPyEndAllowThreads(__tstate);
26575 if (PyErr_Occurred()) SWIG_fail;
26576 }
26577 resultobj = SWIG_Py_Void();
26578 return resultobj;
26579 fail:
26580 return NULL;
26581 }
26582
26583
26584 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26585 PyObject *resultobj = 0;
26586 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26587 bool result;
26588 void *argp1 = 0 ;
26589 int res1 = 0 ;
26590 PyObject *swig_obj[1] ;
26591
26592 if (!args) SWIG_fail;
26593 swig_obj[0] = args;
26594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26595 if (!SWIG_IsOK(res1)) {
26596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26597 }
26598 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26599 {
26600 PyThreadState* __tstate = wxPyBeginAllowThreads();
26601 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 {
26606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26607 }
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26615 PyObject *resultobj = 0;
26616 wxIdleMode arg1 ;
26617 int val1 ;
26618 int ecode1 = 0 ;
26619 PyObject * obj0 = 0 ;
26620 char * kwnames[] = {
26621 (char *) "mode", NULL
26622 };
26623
26624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26625 ecode1 = SWIG_AsVal_int(obj0, &val1);
26626 if (!SWIG_IsOK(ecode1)) {
26627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26628 }
26629 arg1 = static_cast< wxIdleMode >(val1);
26630 {
26631 PyThreadState* __tstate = wxPyBeginAllowThreads();
26632 wxIdleEvent::SetMode(arg1);
26633 wxPyEndAllowThreads(__tstate);
26634 if (PyErr_Occurred()) SWIG_fail;
26635 }
26636 resultobj = SWIG_Py_Void();
26637 return resultobj;
26638 fail:
26639 return NULL;
26640 }
26641
26642
26643 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26644 PyObject *resultobj = 0;
26645 wxIdleMode result;
26646
26647 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (wxIdleMode)wxIdleEvent::GetMode();
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 resultobj = SWIG_From_int(static_cast< int >(result));
26655 return resultobj;
26656 fail:
26657 return NULL;
26658 }
26659
26660
26661 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26662 PyObject *resultobj = 0;
26663 wxWindow *arg1 = (wxWindow *) 0 ;
26664 bool result;
26665 void *argp1 = 0 ;
26666 int res1 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 char * kwnames[] = {
26669 (char *) "win", NULL
26670 };
26671
26672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26674 if (!SWIG_IsOK(res1)) {
26675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26676 }
26677 arg1 = reinterpret_cast< wxWindow * >(argp1);
26678 {
26679 PyThreadState* __tstate = wxPyBeginAllowThreads();
26680 result = (bool)wxIdleEvent::CanSend(arg1);
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 {
26685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26686 }
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 PyObject *obj;
26695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26696 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26697 return SWIG_Py_Void();
26698 }
26699
26700 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26701 return SWIG_Python_InitShadowInstance(args);
26702 }
26703
26704 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26705 PyObject *resultobj = 0;
26706 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26707 int arg2 = (int) 0 ;
26708 wxClipboardTextEvent *result = 0 ;
26709 int val1 ;
26710 int ecode1 = 0 ;
26711 int val2 ;
26712 int ecode2 = 0 ;
26713 PyObject * obj0 = 0 ;
26714 PyObject * obj1 = 0 ;
26715 char * kwnames[] = {
26716 (char *) "type",(char *) "winid", NULL
26717 };
26718
26719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26720 if (obj0) {
26721 ecode1 = SWIG_AsVal_int(obj0, &val1);
26722 if (!SWIG_IsOK(ecode1)) {
26723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26724 }
26725 arg1 = static_cast< wxEventType >(val1);
26726 }
26727 if (obj1) {
26728 ecode2 = SWIG_AsVal_int(obj1, &val2);
26729 if (!SWIG_IsOK(ecode2)) {
26730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26731 }
26732 arg2 = static_cast< int >(val2);
26733 }
26734 {
26735 PyThreadState* __tstate = wxPyBeginAllowThreads();
26736 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26737 wxPyEndAllowThreads(__tstate);
26738 if (PyErr_Occurred()) SWIG_fail;
26739 }
26740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26748 PyObject *obj;
26749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26750 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26751 return SWIG_Py_Void();
26752 }
26753
26754 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 return SWIG_Python_InitShadowInstance(args);
26756 }
26757
26758 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26759 PyObject *resultobj = 0;
26760 int arg1 = (int) 0 ;
26761 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26762 wxPyEvent *result = 0 ;
26763 int val1 ;
26764 int ecode1 = 0 ;
26765 int val2 ;
26766 int ecode2 = 0 ;
26767 PyObject * obj0 = 0 ;
26768 PyObject * obj1 = 0 ;
26769 char * kwnames[] = {
26770 (char *) "winid",(char *) "eventType", NULL
26771 };
26772
26773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26774 if (obj0) {
26775 ecode1 = SWIG_AsVal_int(obj0, &val1);
26776 if (!SWIG_IsOK(ecode1)) {
26777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26778 }
26779 arg1 = static_cast< int >(val1);
26780 }
26781 if (obj1) {
26782 ecode2 = SWIG_AsVal_int(obj1, &val2);
26783 if (!SWIG_IsOK(ecode2)) {
26784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26785 }
26786 arg2 = static_cast< wxEventType >(val2);
26787 }
26788 {
26789 PyThreadState* __tstate = wxPyBeginAllowThreads();
26790 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26795 return resultobj;
26796 fail:
26797 return NULL;
26798 }
26799
26800
26801 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26802 PyObject *resultobj = 0;
26803 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26804 void *argp1 = 0 ;
26805 int res1 = 0 ;
26806 PyObject *swig_obj[1] ;
26807
26808 if (!args) SWIG_fail;
26809 swig_obj[0] = args;
26810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26811 if (!SWIG_IsOK(res1)) {
26812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26813 }
26814 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26815 {
26816 PyThreadState* __tstate = wxPyBeginAllowThreads();
26817 delete arg1;
26818
26819 wxPyEndAllowThreads(__tstate);
26820 if (PyErr_Occurred()) SWIG_fail;
26821 }
26822 resultobj = SWIG_Py_Void();
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26830 PyObject *resultobj = 0;
26831 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26832 PyObject *arg2 = (PyObject *) 0 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 PyObject * obj0 = 0 ;
26836 PyObject * obj1 = 0 ;
26837 char * kwnames[] = {
26838 (char *) "self",(char *) "self", NULL
26839 };
26840
26841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26843 if (!SWIG_IsOK(res1)) {
26844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26845 }
26846 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26847 arg2 = obj1;
26848 {
26849 PyThreadState* __tstate = wxPyBeginAllowThreads();
26850 (arg1)->SetSelf(arg2);
26851 wxPyEndAllowThreads(__tstate);
26852 if (PyErr_Occurred()) SWIG_fail;
26853 }
26854 resultobj = SWIG_Py_Void();
26855 return resultobj;
26856 fail:
26857 return NULL;
26858 }
26859
26860
26861 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26862 PyObject *resultobj = 0;
26863 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26864 PyObject *result = 0 ;
26865 void *argp1 = 0 ;
26866 int res1 = 0 ;
26867 PyObject *swig_obj[1] ;
26868
26869 if (!args) SWIG_fail;
26870 swig_obj[0] = args;
26871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26872 if (!SWIG_IsOK(res1)) {
26873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26874 }
26875 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26876 {
26877 PyThreadState* __tstate = wxPyBeginAllowThreads();
26878 result = (PyObject *)(arg1)->GetSelf();
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 resultobj = result;
26883 return resultobj;
26884 fail:
26885 return NULL;
26886 }
26887
26888
26889 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26890 PyObject *obj;
26891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26892 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26893 return SWIG_Py_Void();
26894 }
26895
26896 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26897 return SWIG_Python_InitShadowInstance(args);
26898 }
26899
26900 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = 0;
26902 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26903 int arg2 = (int) 0 ;
26904 wxPyCommandEvent *result = 0 ;
26905 int val1 ;
26906 int ecode1 = 0 ;
26907 int val2 ;
26908 int ecode2 = 0 ;
26909 PyObject * obj0 = 0 ;
26910 PyObject * obj1 = 0 ;
26911 char * kwnames[] = {
26912 (char *) "eventType",(char *) "id", NULL
26913 };
26914
26915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26916 if (obj0) {
26917 ecode1 = SWIG_AsVal_int(obj0, &val1);
26918 if (!SWIG_IsOK(ecode1)) {
26919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26920 }
26921 arg1 = static_cast< wxEventType >(val1);
26922 }
26923 if (obj1) {
26924 ecode2 = SWIG_AsVal_int(obj1, &val2);
26925 if (!SWIG_IsOK(ecode2)) {
26926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26927 }
26928 arg2 = static_cast< int >(val2);
26929 }
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26944 PyObject *resultobj = 0;
26945 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 PyObject *swig_obj[1] ;
26949
26950 if (!args) SWIG_fail;
26951 swig_obj[0] = args;
26952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26953 if (!SWIG_IsOK(res1)) {
26954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26955 }
26956 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 delete arg1;
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 resultobj = SWIG_Py_Void();
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj = 0;
26973 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26974 PyObject *arg2 = (PyObject *) 0 ;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject * obj0 = 0 ;
26978 PyObject * obj1 = 0 ;
26979 char * kwnames[] = {
26980 (char *) "self",(char *) "self", NULL
26981 };
26982
26983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26985 if (!SWIG_IsOK(res1)) {
26986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26987 }
26988 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26989 arg2 = obj1;
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 (arg1)->SetSelf(arg2);
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 resultobj = SWIG_Py_Void();
26997 return resultobj;
26998 fail:
26999 return NULL;
27000 }
27001
27002
27003 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27004 PyObject *resultobj = 0;
27005 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27006 PyObject *result = 0 ;
27007 void *argp1 = 0 ;
27008 int res1 = 0 ;
27009 PyObject *swig_obj[1] ;
27010
27011 if (!args) SWIG_fail;
27012 swig_obj[0] = args;
27013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27014 if (!SWIG_IsOK(res1)) {
27015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27016 }
27017 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = (PyObject *)(arg1)->GetSelf();
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 resultobj = result;
27025 return resultobj;
27026 fail:
27027 return NULL;
27028 }
27029
27030
27031 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27032 PyObject *obj;
27033 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27034 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27035 return SWIG_Py_Void();
27036 }
27037
27038 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27039 return SWIG_Python_InitShadowInstance(args);
27040 }
27041
27042 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27043 PyObject *resultobj = 0;
27044 wxWindow *arg1 = (wxWindow *) 0 ;
27045 wxDateTime *arg2 = 0 ;
27046 wxEventType arg3 ;
27047 wxDateEvent *result = 0 ;
27048 void *argp1 = 0 ;
27049 int res1 = 0 ;
27050 void *argp2 = 0 ;
27051 int res2 = 0 ;
27052 int val3 ;
27053 int ecode3 = 0 ;
27054 PyObject * obj0 = 0 ;
27055 PyObject * obj1 = 0 ;
27056 PyObject * obj2 = 0 ;
27057 char * kwnames[] = {
27058 (char *) "win",(char *) "dt",(char *) "type", NULL
27059 };
27060
27061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27063 if (!SWIG_IsOK(res1)) {
27064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27065 }
27066 arg1 = reinterpret_cast< wxWindow * >(argp1);
27067 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27068 if (!SWIG_IsOK(res2)) {
27069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27070 }
27071 if (!argp2) {
27072 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27073 }
27074 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27075 ecode3 = SWIG_AsVal_int(obj2, &val3);
27076 if (!SWIG_IsOK(ecode3)) {
27077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27078 }
27079 arg3 = static_cast< wxEventType >(val3);
27080 {
27081 PyThreadState* __tstate = wxPyBeginAllowThreads();
27082 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27083 wxPyEndAllowThreads(__tstate);
27084 if (PyErr_Occurred()) SWIG_fail;
27085 }
27086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27087 return resultobj;
27088 fail:
27089 return NULL;
27090 }
27091
27092
27093 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27094 PyObject *resultobj = 0;
27095 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27096 wxDateTime *result = 0 ;
27097 void *argp1 = 0 ;
27098 int res1 = 0 ;
27099 PyObject *swig_obj[1] ;
27100
27101 if (!args) SWIG_fail;
27102 swig_obj[0] = args;
27103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27104 if (!SWIG_IsOK(res1)) {
27105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27106 }
27107 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27108 {
27109 PyThreadState* __tstate = wxPyBeginAllowThreads();
27110 {
27111 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27112 result = (wxDateTime *) &_result_ref;
27113 }
27114 wxPyEndAllowThreads(__tstate);
27115 if (PyErr_Occurred()) SWIG_fail;
27116 }
27117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27118 return resultobj;
27119 fail:
27120 return NULL;
27121 }
27122
27123
27124 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27125 PyObject *resultobj = 0;
27126 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27127 wxDateTime *arg2 = 0 ;
27128 void *argp1 = 0 ;
27129 int res1 = 0 ;
27130 void *argp2 = 0 ;
27131 int res2 = 0 ;
27132 PyObject * obj0 = 0 ;
27133 PyObject * obj1 = 0 ;
27134 char * kwnames[] = {
27135 (char *) "self",(char *) "date", NULL
27136 };
27137
27138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27140 if (!SWIG_IsOK(res1)) {
27141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27142 }
27143 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27144 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27145 if (!SWIG_IsOK(res2)) {
27146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27147 }
27148 if (!argp2) {
27149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27150 }
27151 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 (arg1)->SetDate((wxDateTime const &)*arg2);
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = SWIG_Py_Void();
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27166 PyObject *obj;
27167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27168 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27169 return SWIG_Py_Void();
27170 }
27171
27172 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27173 return SWIG_Python_InitShadowInstance(args);
27174 }
27175
27176 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27177 PyObject *resultobj = 0;
27178 wxPyApp *result = 0 ;
27179
27180 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 result = (wxPyApp *)new_wxPyApp();
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27188 return resultobj;
27189 fail:
27190 return NULL;
27191 }
27192
27193
27194 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27195 PyObject *resultobj = 0;
27196 wxPyApp *arg1 = (wxPyApp *) 0 ;
27197 void *argp1 = 0 ;
27198 int res1 = 0 ;
27199 PyObject *swig_obj[1] ;
27200
27201 if (!args) SWIG_fail;
27202 swig_obj[0] = args;
27203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27204 if (!SWIG_IsOK(res1)) {
27205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27206 }
27207 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 delete arg1;
27211
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__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27223 PyObject *resultobj = 0;
27224 wxPyApp *arg1 = (wxPyApp *) 0 ;
27225 PyObject *arg2 = (PyObject *) 0 ;
27226 PyObject *arg3 = (PyObject *) 0 ;
27227 bool arg4 ;
27228 void *argp1 = 0 ;
27229 int res1 = 0 ;
27230 bool val4 ;
27231 int ecode4 = 0 ;
27232 PyObject * obj0 = 0 ;
27233 PyObject * obj1 = 0 ;
27234 PyObject * obj2 = 0 ;
27235 PyObject * obj3 = 0 ;
27236 char * kwnames[] = {
27237 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27238 };
27239
27240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27242 if (!SWIG_IsOK(res1)) {
27243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27244 }
27245 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27246 arg2 = obj1;
27247 arg3 = obj2;
27248 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27249 if (!SWIG_IsOK(ecode4)) {
27250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27251 }
27252 arg4 = static_cast< bool >(val4);
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27256 wxPyEndAllowThreads(__tstate);
27257 if (PyErr_Occurred()) SWIG_fail;
27258 }
27259 resultobj = SWIG_Py_Void();
27260 return resultobj;
27261 fail:
27262 return NULL;
27263 }
27264
27265
27266 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27267 PyObject *resultobj = 0;
27268 wxPyApp *arg1 = (wxPyApp *) 0 ;
27269 wxString result;
27270 void *argp1 = 0 ;
27271 int res1 = 0 ;
27272 PyObject *swig_obj[1] ;
27273
27274 if (!args) SWIG_fail;
27275 swig_obj[0] = args;
27276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27277 if (!SWIG_IsOK(res1)) {
27278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27279 }
27280 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27281 {
27282 PyThreadState* __tstate = wxPyBeginAllowThreads();
27283 result = ((wxPyApp const *)arg1)->GetAppName();
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 {
27288 #if wxUSE_UNICODE
27289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27290 #else
27291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27292 #endif
27293 }
27294 return resultobj;
27295 fail:
27296 return NULL;
27297 }
27298
27299
27300 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27301 PyObject *resultobj = 0;
27302 wxPyApp *arg1 = (wxPyApp *) 0 ;
27303 wxString *arg2 = 0 ;
27304 void *argp1 = 0 ;
27305 int res1 = 0 ;
27306 bool temp2 = false ;
27307 PyObject * obj0 = 0 ;
27308 PyObject * obj1 = 0 ;
27309 char * kwnames[] = {
27310 (char *) "self",(char *) "name", NULL
27311 };
27312
27313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27315 if (!SWIG_IsOK(res1)) {
27316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27317 }
27318 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27319 {
27320 arg2 = wxString_in_helper(obj1);
27321 if (arg2 == NULL) SWIG_fail;
27322 temp2 = true;
27323 }
27324 {
27325 PyThreadState* __tstate = wxPyBeginAllowThreads();
27326 (arg1)->SetAppName((wxString const &)*arg2);
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 resultobj = SWIG_Py_Void();
27331 {
27332 if (temp2)
27333 delete arg2;
27334 }
27335 return resultobj;
27336 fail:
27337 {
27338 if (temp2)
27339 delete arg2;
27340 }
27341 return NULL;
27342 }
27343
27344
27345 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27346 PyObject *resultobj = 0;
27347 wxPyApp *arg1 = (wxPyApp *) 0 ;
27348 wxString result;
27349 void *argp1 = 0 ;
27350 int res1 = 0 ;
27351 PyObject *swig_obj[1] ;
27352
27353 if (!args) SWIG_fail;
27354 swig_obj[0] = args;
27355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27356 if (!SWIG_IsOK(res1)) {
27357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27358 }
27359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27360 {
27361 PyThreadState* __tstate = wxPyBeginAllowThreads();
27362 result = ((wxPyApp const *)arg1)->GetClassName();
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 #if wxUSE_UNICODE
27368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27369 #else
27370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27371 #endif
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27380 PyObject *resultobj = 0;
27381 wxPyApp *arg1 = (wxPyApp *) 0 ;
27382 wxString *arg2 = 0 ;
27383 void *argp1 = 0 ;
27384 int res1 = 0 ;
27385 bool temp2 = false ;
27386 PyObject * obj0 = 0 ;
27387 PyObject * obj1 = 0 ;
27388 char * kwnames[] = {
27389 (char *) "self",(char *) "name", NULL
27390 };
27391
27392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27394 if (!SWIG_IsOK(res1)) {
27395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27396 }
27397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27398 {
27399 arg2 = wxString_in_helper(obj1);
27400 if (arg2 == NULL) SWIG_fail;
27401 temp2 = true;
27402 }
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 (arg1)->SetClassName((wxString const &)*arg2);
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 resultobj = SWIG_Py_Void();
27410 {
27411 if (temp2)
27412 delete arg2;
27413 }
27414 return resultobj;
27415 fail:
27416 {
27417 if (temp2)
27418 delete arg2;
27419 }
27420 return NULL;
27421 }
27422
27423
27424 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27425 PyObject *resultobj = 0;
27426 wxPyApp *arg1 = (wxPyApp *) 0 ;
27427 wxString *result = 0 ;
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_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27437 }
27438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27439 {
27440 PyThreadState* __tstate = wxPyBeginAllowThreads();
27441 {
27442 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27443 result = (wxString *) &_result_ref;
27444 }
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 {
27449 #if wxUSE_UNICODE
27450 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27451 #else
27452 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27453 #endif
27454 }
27455 return resultobj;
27456 fail:
27457 return NULL;
27458 }
27459
27460
27461 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27462 PyObject *resultobj = 0;
27463 wxPyApp *arg1 = (wxPyApp *) 0 ;
27464 wxString *arg2 = 0 ;
27465 void *argp1 = 0 ;
27466 int res1 = 0 ;
27467 bool temp2 = false ;
27468 PyObject * obj0 = 0 ;
27469 PyObject * obj1 = 0 ;
27470 char * kwnames[] = {
27471 (char *) "self",(char *) "name", NULL
27472 };
27473
27474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27476 if (!SWIG_IsOK(res1)) {
27477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27478 }
27479 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27480 {
27481 arg2 = wxString_in_helper(obj1);
27482 if (arg2 == NULL) SWIG_fail;
27483 temp2 = true;
27484 }
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 (arg1)->SetVendorName((wxString const &)*arg2);
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_Py_Void();
27492 {
27493 if (temp2)
27494 delete arg2;
27495 }
27496 return resultobj;
27497 fail:
27498 {
27499 if (temp2)
27500 delete arg2;
27501 }
27502 return NULL;
27503 }
27504
27505
27506 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27507 PyObject *resultobj = 0;
27508 wxPyApp *arg1 = (wxPyApp *) 0 ;
27509 wxAppTraits *result = 0 ;
27510 void *argp1 = 0 ;
27511 int res1 = 0 ;
27512 PyObject *swig_obj[1] ;
27513
27514 if (!args) SWIG_fail;
27515 swig_obj[0] = args;
27516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27517 if (!SWIG_IsOK(res1)) {
27518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27519 }
27520 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 result = (wxAppTraits *)(arg1)->GetTraits();
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27535 PyObject *resultobj = 0;
27536 wxPyApp *arg1 = (wxPyApp *) 0 ;
27537 void *argp1 = 0 ;
27538 int res1 = 0 ;
27539 PyObject *swig_obj[1] ;
27540
27541 if (!args) SWIG_fail;
27542 swig_obj[0] = args;
27543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27544 if (!SWIG_IsOK(res1)) {
27545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27546 }
27547 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 (arg1)->ProcessPendingEvents();
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 resultobj = SWIG_Py_Void();
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27562 PyObject *resultobj = 0;
27563 wxPyApp *arg1 = (wxPyApp *) 0 ;
27564 bool arg2 = (bool) false ;
27565 bool result;
27566 void *argp1 = 0 ;
27567 int res1 = 0 ;
27568 bool val2 ;
27569 int ecode2 = 0 ;
27570 PyObject * obj0 = 0 ;
27571 PyObject * obj1 = 0 ;
27572 char * kwnames[] = {
27573 (char *) "self",(char *) "onlyIfNeeded", NULL
27574 };
27575
27576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27580 }
27581 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27582 if (obj1) {
27583 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27584 if (!SWIG_IsOK(ecode2)) {
27585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27586 }
27587 arg2 = static_cast< bool >(val2);
27588 }
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 result = (bool)(arg1)->Yield(arg2);
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 {
27596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27597 }
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27605 PyObject *resultobj = 0;
27606 wxPyApp *arg1 = (wxPyApp *) 0 ;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 PyObject *swig_obj[1] ;
27610
27611 if (!args) SWIG_fail;
27612 swig_obj[0] = args;
27613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27614 if (!SWIG_IsOK(res1)) {
27615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27616 }
27617 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 (arg1)->WakeUpIdle();
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 resultobj = SWIG_Py_Void();
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27632 PyObject *resultobj = 0;
27633 bool result;
27634
27635 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (bool)wxPyApp::IsMainLoopRunning();
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 {
27643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27644 }
27645 return resultobj;
27646 fail:
27647 return NULL;
27648 }
27649
27650
27651 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27652 PyObject *resultobj = 0;
27653 wxPyApp *arg1 = (wxPyApp *) 0 ;
27654 int result;
27655 void *argp1 = 0 ;
27656 int res1 = 0 ;
27657 PyObject *swig_obj[1] ;
27658
27659 if (!args) SWIG_fail;
27660 swig_obj[0] = args;
27661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27664 }
27665 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27666 {
27667 PyThreadState* __tstate = wxPyBeginAllowThreads();
27668 result = (int)(arg1)->MainLoop();
27669 wxPyEndAllowThreads(__tstate);
27670 if (PyErr_Occurred()) SWIG_fail;
27671 }
27672 resultobj = SWIG_From_int(static_cast< int >(result));
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27680 PyObject *resultobj = 0;
27681 wxPyApp *arg1 = (wxPyApp *) 0 ;
27682 void *argp1 = 0 ;
27683 int res1 = 0 ;
27684 PyObject *swig_obj[1] ;
27685
27686 if (!args) SWIG_fail;
27687 swig_obj[0] = args;
27688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27689 if (!SWIG_IsOK(res1)) {
27690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27691 }
27692 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27693 {
27694 PyThreadState* __tstate = wxPyBeginAllowThreads();
27695 (arg1)->Exit();
27696 wxPyEndAllowThreads(__tstate);
27697 if (PyErr_Occurred()) SWIG_fail;
27698 }
27699 resultobj = SWIG_Py_Void();
27700 return resultobj;
27701 fail:
27702 return NULL;
27703 }
27704
27705
27706 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27707 PyObject *resultobj = 0;
27708 wxPyApp *arg1 = (wxPyApp *) 0 ;
27709 void *argp1 = 0 ;
27710 int res1 = 0 ;
27711 PyObject *swig_obj[1] ;
27712
27713 if (!args) SWIG_fail;
27714 swig_obj[0] = args;
27715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27716 if (!SWIG_IsOK(res1)) {
27717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27718 }
27719 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27720 {
27721 PyThreadState* __tstate = wxPyBeginAllowThreads();
27722 (arg1)->ExitMainLoop();
27723 wxPyEndAllowThreads(__tstate);
27724 if (PyErr_Occurred()) SWIG_fail;
27725 }
27726 resultobj = SWIG_Py_Void();
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27734 PyObject *resultobj = 0;
27735 wxPyApp *arg1 = (wxPyApp *) 0 ;
27736 bool result;
27737 void *argp1 = 0 ;
27738 int res1 = 0 ;
27739 PyObject *swig_obj[1] ;
27740
27741 if (!args) SWIG_fail;
27742 swig_obj[0] = args;
27743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27744 if (!SWIG_IsOK(res1)) {
27745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27746 }
27747 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (bool)(arg1)->Pending();
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764 PyObject *resultobj = 0;
27765 wxPyApp *arg1 = (wxPyApp *) 0 ;
27766 bool result;
27767 void *argp1 = 0 ;
27768 int res1 = 0 ;
27769 PyObject *swig_obj[1] ;
27770
27771 if (!args) SWIG_fail;
27772 swig_obj[0] = args;
27773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27774 if (!SWIG_IsOK(res1)) {
27775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27776 }
27777 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)(arg1)->Dispatch();
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27794 PyObject *resultobj = 0;
27795 wxPyApp *arg1 = (wxPyApp *) 0 ;
27796 bool result;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 PyObject *swig_obj[1] ;
27800
27801 if (!args) SWIG_fail;
27802 swig_obj[0] = args;
27803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27804 if (!SWIG_IsOK(res1)) {
27805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27806 }
27807 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 result = (bool)(arg1)->ProcessIdle();
27811 wxPyEndAllowThreads(__tstate);
27812 if (PyErr_Occurred()) SWIG_fail;
27813 }
27814 {
27815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27816 }
27817 return resultobj;
27818 fail:
27819 return NULL;
27820 }
27821
27822
27823 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27824 PyObject *resultobj = 0;
27825 wxPyApp *arg1 = (wxPyApp *) 0 ;
27826 wxWindow *arg2 = (wxWindow *) 0 ;
27827 wxIdleEvent *arg3 = 0 ;
27828 bool result;
27829 void *argp1 = 0 ;
27830 int res1 = 0 ;
27831 void *argp2 = 0 ;
27832 int res2 = 0 ;
27833 void *argp3 = 0 ;
27834 int res3 = 0 ;
27835 PyObject * obj0 = 0 ;
27836 PyObject * obj1 = 0 ;
27837 PyObject * obj2 = 0 ;
27838 char * kwnames[] = {
27839 (char *) "self",(char *) "win",(char *) "event", NULL
27840 };
27841
27842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27849 if (!SWIG_IsOK(res2)) {
27850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27851 }
27852 arg2 = reinterpret_cast< wxWindow * >(argp2);
27853 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27854 if (!SWIG_IsOK(res3)) {
27855 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27856 }
27857 if (!argp3) {
27858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27859 }
27860 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27877 PyObject *resultobj = 0;
27878 wxPyApp *arg1 = (wxPyApp *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 PyObject *swig_obj[1] ;
27883
27884 if (!args) SWIG_fail;
27885 swig_obj[0] = args;
27886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27887 if (!SWIG_IsOK(res1)) {
27888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27889 }
27890 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 result = (bool)((wxPyApp const *)arg1)->IsActive();
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 {
27898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27899 }
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj = 0;
27908 wxPyApp *arg1 = (wxPyApp *) 0 ;
27909 wxWindow *arg2 = (wxWindow *) 0 ;
27910 void *argp1 = 0 ;
27911 int res1 = 0 ;
27912 void *argp2 = 0 ;
27913 int res2 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "self",(char *) "win", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27924 }
27925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27927 if (!SWIG_IsOK(res2)) {
27928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27929 }
27930 arg2 = reinterpret_cast< wxWindow * >(argp2);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 (arg1)->SetTopWindow(arg2);
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_Py_Void();
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27945 PyObject *resultobj = 0;
27946 wxPyApp *arg1 = (wxPyApp *) 0 ;
27947 wxWindow *result = 0 ;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 PyObject *swig_obj[1] ;
27951
27952 if (!args) SWIG_fail;
27953 swig_obj[0] = args;
27954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27955 if (!SWIG_IsOK(res1)) {
27956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27957 }
27958 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27959 {
27960 PyThreadState* __tstate = wxPyBeginAllowThreads();
27961 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27962 wxPyEndAllowThreads(__tstate);
27963 if (PyErr_Occurred()) SWIG_fail;
27964 }
27965 {
27966 resultobj = wxPyMake_wxObject(result, (bool)0);
27967 }
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27975 PyObject *resultobj = 0;
27976 wxPyApp *arg1 = (wxPyApp *) 0 ;
27977 bool arg2 ;
27978 void *argp1 = 0 ;
27979 int res1 = 0 ;
27980 bool val2 ;
27981 int ecode2 = 0 ;
27982 PyObject * obj0 = 0 ;
27983 PyObject * obj1 = 0 ;
27984 char * kwnames[] = {
27985 (char *) "self",(char *) "flag", NULL
27986 };
27987
27988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27990 if (!SWIG_IsOK(res1)) {
27991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27992 }
27993 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27994 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27995 if (!SWIG_IsOK(ecode2)) {
27996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27997 }
27998 arg2 = static_cast< bool >(val2);
27999 {
28000 PyThreadState* __tstate = wxPyBeginAllowThreads();
28001 (arg1)->SetExitOnFrameDelete(arg2);
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 resultobj = SWIG_Py_Void();
28006 return resultobj;
28007 fail:
28008 return NULL;
28009 }
28010
28011
28012 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28013 PyObject *resultobj = 0;
28014 wxPyApp *arg1 = (wxPyApp *) 0 ;
28015 bool result;
28016 void *argp1 = 0 ;
28017 int res1 = 0 ;
28018 PyObject *swig_obj[1] ;
28019
28020 if (!args) SWIG_fail;
28021 swig_obj[0] = args;
28022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28023 if (!SWIG_IsOK(res1)) {
28024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28025 }
28026 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28027 {
28028 PyThreadState* __tstate = wxPyBeginAllowThreads();
28029 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28030 wxPyEndAllowThreads(__tstate);
28031 if (PyErr_Occurred()) SWIG_fail;
28032 }
28033 {
28034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28035 }
28036 return resultobj;
28037 fail:
28038 return NULL;
28039 }
28040
28041
28042 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28043 PyObject *resultobj = 0;
28044 wxPyApp *arg1 = (wxPyApp *) 0 ;
28045 bool arg2 ;
28046 void *argp1 = 0 ;
28047 int res1 = 0 ;
28048 bool val2 ;
28049 int ecode2 = 0 ;
28050 PyObject * obj0 = 0 ;
28051 PyObject * obj1 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "self",(char *) "flag", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28058 if (!SWIG_IsOK(res1)) {
28059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28060 }
28061 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28062 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28063 if (!SWIG_IsOK(ecode2)) {
28064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28065 }
28066 arg2 = static_cast< bool >(val2);
28067 {
28068 PyThreadState* __tstate = wxPyBeginAllowThreads();
28069 (arg1)->SetUseBestVisual(arg2);
28070 wxPyEndAllowThreads(__tstate);
28071 if (PyErr_Occurred()) SWIG_fail;
28072 }
28073 resultobj = SWIG_Py_Void();
28074 return resultobj;
28075 fail:
28076 return NULL;
28077 }
28078
28079
28080 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28081 PyObject *resultobj = 0;
28082 wxPyApp *arg1 = (wxPyApp *) 0 ;
28083 bool result;
28084 void *argp1 = 0 ;
28085 int res1 = 0 ;
28086 PyObject *swig_obj[1] ;
28087
28088 if (!args) SWIG_fail;
28089 swig_obj[0] = args;
28090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28091 if (!SWIG_IsOK(res1)) {
28092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28093 }
28094 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 {
28102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28103 }
28104 return resultobj;
28105 fail:
28106 return NULL;
28107 }
28108
28109
28110 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28111 PyObject *resultobj = 0;
28112 wxPyApp *arg1 = (wxPyApp *) 0 ;
28113 int arg2 ;
28114 void *argp1 = 0 ;
28115 int res1 = 0 ;
28116 int val2 ;
28117 int ecode2 = 0 ;
28118 PyObject * obj0 = 0 ;
28119 PyObject * obj1 = 0 ;
28120 char * kwnames[] = {
28121 (char *) "self",(char *) "mode", NULL
28122 };
28123
28124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28126 if (!SWIG_IsOK(res1)) {
28127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28128 }
28129 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28130 ecode2 = SWIG_AsVal_int(obj1, &val2);
28131 if (!SWIG_IsOK(ecode2)) {
28132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28133 }
28134 arg2 = static_cast< int >(val2);
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 (arg1)->SetPrintMode(arg2);
28138 wxPyEndAllowThreads(__tstate);
28139 if (PyErr_Occurred()) SWIG_fail;
28140 }
28141 resultobj = SWIG_Py_Void();
28142 return resultobj;
28143 fail:
28144 return NULL;
28145 }
28146
28147
28148 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28149 PyObject *resultobj = 0;
28150 wxPyApp *arg1 = (wxPyApp *) 0 ;
28151 int result;
28152 void *argp1 = 0 ;
28153 int res1 = 0 ;
28154 PyObject *swig_obj[1] ;
28155
28156 if (!args) SWIG_fail;
28157 swig_obj[0] = args;
28158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28159 if (!SWIG_IsOK(res1)) {
28160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28161 }
28162 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_From_int(static_cast< int >(result));
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 wxPyApp *arg1 = (wxPyApp *) 0 ;
28179 int arg2 ;
28180 void *argp1 = 0 ;
28181 int res1 = 0 ;
28182 int val2 ;
28183 int ecode2 = 0 ;
28184 PyObject * obj0 = 0 ;
28185 PyObject * obj1 = 0 ;
28186 char * kwnames[] = {
28187 (char *) "self",(char *) "mode", NULL
28188 };
28189
28190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28192 if (!SWIG_IsOK(res1)) {
28193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28194 }
28195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28196 ecode2 = SWIG_AsVal_int(obj1, &val2);
28197 if (!SWIG_IsOK(ecode2)) {
28198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28199 }
28200 arg2 = static_cast< int >(val2);
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 (arg1)->SetAssertMode(arg2);
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_Py_Void();
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28215 PyObject *resultobj = 0;
28216 wxPyApp *arg1 = (wxPyApp *) 0 ;
28217 int result;
28218 void *argp1 = 0 ;
28219 int res1 = 0 ;
28220 PyObject *swig_obj[1] ;
28221
28222 if (!args) SWIG_fail;
28223 swig_obj[0] = args;
28224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28225 if (!SWIG_IsOK(res1)) {
28226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28227 }
28228 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 result = (int)(arg1)->GetAssertMode();
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 resultobj = SWIG_From_int(static_cast< int >(result));
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28243 PyObject *resultobj = 0;
28244 bool result;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 {
28254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28255 }
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28263 PyObject *resultobj = 0;
28264 long result;
28265
28266 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (long)wxPyApp::GetMacAboutMenuItemId();
28270 wxPyEndAllowThreads(__tstate);
28271 if (PyErr_Occurred()) SWIG_fail;
28272 }
28273 resultobj = SWIG_From_long(static_cast< long >(result));
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28281 PyObject *resultobj = 0;
28282 long result;
28283
28284 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28285 {
28286 PyThreadState* __tstate = wxPyBeginAllowThreads();
28287 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28288 wxPyEndAllowThreads(__tstate);
28289 if (PyErr_Occurred()) SWIG_fail;
28290 }
28291 resultobj = SWIG_From_long(static_cast< long >(result));
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28299 PyObject *resultobj = 0;
28300 long result;
28301
28302 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (long)wxPyApp::GetMacExitMenuItemId();
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_From_long(static_cast< long >(result));
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28317 PyObject *resultobj = 0;
28318 wxString result;
28319
28320 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = wxPyApp::GetMacHelpMenuTitleName();
28324 wxPyEndAllowThreads(__tstate);
28325 if (PyErr_Occurred()) SWIG_fail;
28326 }
28327 {
28328 #if wxUSE_UNICODE
28329 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28330 #else
28331 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28332 #endif
28333 }
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28341 PyObject *resultobj = 0;
28342 bool arg1 ;
28343 bool val1 ;
28344 int ecode1 = 0 ;
28345 PyObject * obj0 = 0 ;
28346 char * kwnames[] = {
28347 (char *) "val", NULL
28348 };
28349
28350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28351 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28352 if (!SWIG_IsOK(ecode1)) {
28353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28354 }
28355 arg1 = static_cast< bool >(val1);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
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_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28370 PyObject *resultobj = 0;
28371 long arg1 ;
28372 long val1 ;
28373 int ecode1 = 0 ;
28374 PyObject * obj0 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "val", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28380 ecode1 = SWIG_AsVal_long(obj0, &val1);
28381 if (!SWIG_IsOK(ecode1)) {
28382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28383 }
28384 arg1 = static_cast< long >(val1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 wxPyApp::SetMacAboutMenuItemId(arg1);
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_Py_Void();
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = 0;
28400 long arg1 ;
28401 long val1 ;
28402 int ecode1 = 0 ;
28403 PyObject * obj0 = 0 ;
28404 char * kwnames[] = {
28405 (char *) "val", NULL
28406 };
28407
28408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28409 ecode1 = SWIG_AsVal_long(obj0, &val1);
28410 if (!SWIG_IsOK(ecode1)) {
28411 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28412 }
28413 arg1 = static_cast< long >(val1);
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28417 wxPyEndAllowThreads(__tstate);
28418 if (PyErr_Occurred()) SWIG_fail;
28419 }
28420 resultobj = SWIG_Py_Void();
28421 return resultobj;
28422 fail:
28423 return NULL;
28424 }
28425
28426
28427 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28428 PyObject *resultobj = 0;
28429 long arg1 ;
28430 long val1 ;
28431 int ecode1 = 0 ;
28432 PyObject * obj0 = 0 ;
28433 char * kwnames[] = {
28434 (char *) "val", NULL
28435 };
28436
28437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28438 ecode1 = SWIG_AsVal_long(obj0, &val1);
28439 if (!SWIG_IsOK(ecode1)) {
28440 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28441 }
28442 arg1 = static_cast< long >(val1);
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 wxPyApp::SetMacExitMenuItemId(arg1);
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 resultobj = SWIG_Py_Void();
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj = 0;
28458 wxString *arg1 = 0 ;
28459 bool temp1 = false ;
28460 PyObject * obj0 = 0 ;
28461 char * kwnames[] = {
28462 (char *) "val", NULL
28463 };
28464
28465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28466 {
28467 arg1 = wxString_in_helper(obj0);
28468 if (arg1 == NULL) SWIG_fail;
28469 temp1 = true;
28470 }
28471 {
28472 PyThreadState* __tstate = wxPyBeginAllowThreads();
28473 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 resultobj = SWIG_Py_Void();
28478 {
28479 if (temp1)
28480 delete arg1;
28481 }
28482 return resultobj;
28483 fail:
28484 {
28485 if (temp1)
28486 delete arg1;
28487 }
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *resultobj = 0;
28494 wxPyApp *arg1 = (wxPyApp *) 0 ;
28495 void *argp1 = 0 ;
28496 int res1 = 0 ;
28497 PyObject *swig_obj[1] ;
28498
28499 if (!args) SWIG_fail;
28500 swig_obj[0] = args;
28501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28502 if (!SWIG_IsOK(res1)) {
28503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28504 }
28505 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28506 {
28507 PyThreadState* __tstate = wxPyBeginAllowThreads();
28508 (arg1)->_BootstrapApp();
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 resultobj = SWIG_Py_Void();
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *resultobj = 0;
28521 int result;
28522
28523 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (int)wxPyApp_GetComCtl32Version();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 resultobj = SWIG_From_int(static_cast< int >(result));
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 bool result;
28540
28541 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (bool)wxPyApp_DisplayAvailable();
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28558 PyObject *obj;
28559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28560 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28561 return SWIG_Py_Void();
28562 }
28563
28564 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28565 return SWIG_Python_InitShadowInstance(args);
28566 }
28567
28568 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28569 PyObject *resultobj = 0;
28570
28571 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 wxExit();
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 bool result;
28588
28589 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28590 {
28591 PyThreadState* __tstate = wxPyBeginAllowThreads();
28592 result = (bool)wxYield();
28593 wxPyEndAllowThreads(__tstate);
28594 if (PyErr_Occurred()) SWIG_fail;
28595 }
28596 {
28597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28606 PyObject *resultobj = 0;
28607 bool result;
28608
28609 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28610 {
28611 PyThreadState* __tstate = wxPyBeginAllowThreads();
28612 result = (bool)wxYieldIfNeeded();
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 {
28617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28618 }
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28626 PyObject *resultobj = 0;
28627 wxWindow *arg1 = (wxWindow *) NULL ;
28628 bool arg2 = (bool) false ;
28629 bool result;
28630 void *argp1 = 0 ;
28631 int res1 = 0 ;
28632 bool val2 ;
28633 int ecode2 = 0 ;
28634 PyObject * obj0 = 0 ;
28635 PyObject * obj1 = 0 ;
28636 char * kwnames[] = {
28637 (char *) "win",(char *) "onlyIfNeeded", NULL
28638 };
28639
28640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28641 if (obj0) {
28642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28643 if (!SWIG_IsOK(res1)) {
28644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28645 }
28646 arg1 = reinterpret_cast< wxWindow * >(argp1);
28647 }
28648 if (obj1) {
28649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28650 if (!SWIG_IsOK(ecode2)) {
28651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28652 }
28653 arg2 = static_cast< bool >(val2);
28654 }
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (bool)wxSafeYield(arg1,arg2);
28658 wxPyEndAllowThreads(__tstate);
28659 if (PyErr_Occurred()) SWIG_fail;
28660 }
28661 {
28662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28663 }
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28671 PyObject *resultobj = 0;
28672
28673 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 wxWakeUpIdle();
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 resultobj = SWIG_Py_Void();
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28688 PyObject *resultobj = 0;
28689 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28690 wxEvent *arg2 = 0 ;
28691 void *argp1 = 0 ;
28692 int res1 = 0 ;
28693 void *argp2 = 0 ;
28694 int res2 = 0 ;
28695 PyObject * obj0 = 0 ;
28696 PyObject * obj1 = 0 ;
28697 char * kwnames[] = {
28698 (char *) "dest",(char *) "event", NULL
28699 };
28700
28701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28703 if (!SWIG_IsOK(res1)) {
28704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28705 }
28706 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28707 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28708 if (!SWIG_IsOK(res2)) {
28709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28710 }
28711 if (!argp2) {
28712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28713 }
28714 arg2 = reinterpret_cast< wxEvent * >(argp2);
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 wxPostEvent(arg1,*arg2);
28718 wxPyEndAllowThreads(__tstate);
28719 if (PyErr_Occurred()) SWIG_fail;
28720 }
28721 resultobj = SWIG_Py_Void();
28722 return resultobj;
28723 fail:
28724 return NULL;
28725 }
28726
28727
28728 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28729 PyObject *resultobj = 0;
28730
28731 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 wxApp_CleanUp();
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_Py_Void();
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28746 PyObject *resultobj = 0;
28747 wxPyApp *result = 0 ;
28748
28749 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxPyApp *)wxPyGetApp();
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = wxPyMake_wxObject(result, 0);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj = 0;
28767 char *arg1 = (char *) 0 ;
28768 int res1 ;
28769 char *buf1 = 0 ;
28770 int alloc1 = 0 ;
28771 PyObject * obj0 = 0 ;
28772 char * kwnames[] = {
28773 (char *) "encoding", NULL
28774 };
28775
28776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28777 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28778 if (!SWIG_IsOK(res1)) {
28779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28780 }
28781 arg1 = buf1;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 wxSetDefaultPyEncoding((char const *)arg1);
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_Py_Void();
28789 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28790 return resultobj;
28791 fail:
28792 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28793 return NULL;
28794 }
28795
28796
28797 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28798 PyObject *resultobj = 0;
28799 char *result = 0 ;
28800
28801 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = (char *)wxGetDefaultPyEncoding();
28805 wxPyEndAllowThreads(__tstate);
28806 if (PyErr_Occurred()) SWIG_fail;
28807 }
28808 resultobj = SWIG_FromCharPtr(result);
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28816 PyObject *resultobj = 0;
28817 wxEventLoop *result = 0 ;
28818
28819 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 result = (wxEventLoop *)new wxEventLoop();
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28834 PyObject *resultobj = 0;
28835 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 PyObject *swig_obj[1] ;
28839
28840 if (!args) SWIG_fail;
28841 swig_obj[0] = args;
28842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28843 if (!SWIG_IsOK(res1)) {
28844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28845 }
28846 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 delete arg1;
28850
28851 wxPyEndAllowThreads(__tstate);
28852 if (PyErr_Occurred()) SWIG_fail;
28853 }
28854 resultobj = SWIG_Py_Void();
28855 return resultobj;
28856 fail:
28857 return NULL;
28858 }
28859
28860
28861 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28862 PyObject *resultobj = 0;
28863 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28864 int result;
28865 void *argp1 = 0 ;
28866 int res1 = 0 ;
28867 PyObject *swig_obj[1] ;
28868
28869 if (!args) SWIG_fail;
28870 swig_obj[0] = args;
28871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28874 }
28875 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (int)(arg1)->Run();
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_From_int(static_cast< int >(result));
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28892 int arg2 = (int) 0 ;
28893 void *argp1 = 0 ;
28894 int res1 = 0 ;
28895 int val2 ;
28896 int ecode2 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char * kwnames[] = {
28900 (char *) "self",(char *) "rc", NULL
28901 };
28902
28903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28907 }
28908 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28909 if (obj1) {
28910 ecode2 = SWIG_AsVal_int(obj1, &val2);
28911 if (!SWIG_IsOK(ecode2)) {
28912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28913 }
28914 arg2 = static_cast< int >(val2);
28915 }
28916 {
28917 PyThreadState* __tstate = wxPyBeginAllowThreads();
28918 (arg1)->Exit(arg2);
28919 wxPyEndAllowThreads(__tstate);
28920 if (PyErr_Occurred()) SWIG_fail;
28921 }
28922 resultobj = SWIG_Py_Void();
28923 return resultobj;
28924 fail:
28925 return NULL;
28926 }
28927
28928
28929 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28930 PyObject *resultobj = 0;
28931 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28932 bool result;
28933 void *argp1 = 0 ;
28934 int res1 = 0 ;
28935 PyObject *swig_obj[1] ;
28936
28937 if (!args) SWIG_fail;
28938 swig_obj[0] = args;
28939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28940 if (!SWIG_IsOK(res1)) {
28941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28942 }
28943 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28944 {
28945 PyThreadState* __tstate = wxPyBeginAllowThreads();
28946 result = (bool)((wxEventLoop const *)arg1)->Pending();
28947 wxPyEndAllowThreads(__tstate);
28948 if (PyErr_Occurred()) SWIG_fail;
28949 }
28950 {
28951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28952 }
28953 return resultobj;
28954 fail:
28955 return NULL;
28956 }
28957
28958
28959 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28960 PyObject *resultobj = 0;
28961 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28962 bool result;
28963 void *argp1 = 0 ;
28964 int res1 = 0 ;
28965 PyObject *swig_obj[1] ;
28966
28967 if (!args) SWIG_fail;
28968 swig_obj[0] = args;
28969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28970 if (!SWIG_IsOK(res1)) {
28971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28972 }
28973 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 result = (bool)(arg1)->Dispatch();
28977 wxPyEndAllowThreads(__tstate);
28978 if (PyErr_Occurred()) SWIG_fail;
28979 }
28980 {
28981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28982 }
28983 return resultobj;
28984 fail:
28985 return NULL;
28986 }
28987
28988
28989 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28990 PyObject *resultobj = 0;
28991 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28992 bool result;
28993 void *argp1 = 0 ;
28994 int res1 = 0 ;
28995 PyObject *swig_obj[1] ;
28996
28997 if (!args) SWIG_fail;
28998 swig_obj[0] = args;
28999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29000 if (!SWIG_IsOK(res1)) {
29001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29002 }
29003 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 {
29011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29012 }
29013 return resultobj;
29014 fail:
29015 return NULL;
29016 }
29017
29018
29019 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29020 PyObject *resultobj = 0;
29021 wxEventLoop *result = 0 ;
29022
29023 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29024 {
29025 PyThreadState* __tstate = wxPyBeginAllowThreads();
29026 result = (wxEventLoop *)wxEventLoop::GetActive();
29027 wxPyEndAllowThreads(__tstate);
29028 if (PyErr_Occurred()) SWIG_fail;
29029 }
29030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29038 PyObject *resultobj = 0;
29039 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29040 void *argp1 = 0 ;
29041 int res1 = 0 ;
29042 PyObject * obj0 = 0 ;
29043 char * kwnames[] = {
29044 (char *) "loop", NULL
29045 };
29046
29047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29051 }
29052 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 wxEventLoop::SetActive(arg1);
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 resultobj = SWIG_Py_Void();
29060 return resultobj;
29061 fail:
29062 return NULL;
29063 }
29064
29065
29066 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 PyObject *obj;
29068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29069 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29070 return SWIG_Py_Void();
29071 }
29072
29073 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29074 return SWIG_Python_InitShadowInstance(args);
29075 }
29076
29077 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29080 wxEventLoopActivator *result = 0 ;
29081 void *argp1 = 0 ;
29082 int res1 = 0 ;
29083 PyObject * obj0 = 0 ;
29084 char * kwnames[] = {
29085 (char *) "evtLoop", NULL
29086 };
29087
29088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29090 if (!SWIG_IsOK(res1)) {
29091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29092 }
29093 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29097 wxPyEndAllowThreads(__tstate);
29098 if (PyErr_Occurred()) SWIG_fail;
29099 }
29100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *resultobj = 0;
29109 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29110 void *argp1 = 0 ;
29111 int res1 = 0 ;
29112 PyObject *swig_obj[1] ;
29113
29114 if (!args) SWIG_fail;
29115 swig_obj[0] = args;
29116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29117 if (!SWIG_IsOK(res1)) {
29118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29119 }
29120 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29121 {
29122 PyThreadState* __tstate = wxPyBeginAllowThreads();
29123 delete arg1;
29124
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_Py_Void();
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *obj;
29137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29138 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29139 return SWIG_Py_Void();
29140 }
29141
29142 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 return SWIG_Python_InitShadowInstance(args);
29144 }
29145
29146 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29147 PyObject *resultobj = 0;
29148 int arg1 = (int) 0 ;
29149 int arg2 = (int) 0 ;
29150 int arg3 = (int) 0 ;
29151 wxAcceleratorEntry *result = 0 ;
29152 int val1 ;
29153 int ecode1 = 0 ;
29154 int val2 ;
29155 int ecode2 = 0 ;
29156 int val3 ;
29157 int ecode3 = 0 ;
29158 PyObject * obj0 = 0 ;
29159 PyObject * obj1 = 0 ;
29160 PyObject * obj2 = 0 ;
29161 char * kwnames[] = {
29162 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29163 };
29164
29165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29166 if (obj0) {
29167 ecode1 = SWIG_AsVal_int(obj0, &val1);
29168 if (!SWIG_IsOK(ecode1)) {
29169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29170 }
29171 arg1 = static_cast< int >(val1);
29172 }
29173 if (obj1) {
29174 ecode2 = SWIG_AsVal_int(obj1, &val2);
29175 if (!SWIG_IsOK(ecode2)) {
29176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29177 }
29178 arg2 = static_cast< int >(val2);
29179 }
29180 if (obj2) {
29181 ecode3 = SWIG_AsVal_int(obj2, &val3);
29182 if (!SWIG_IsOK(ecode3)) {
29183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29184 }
29185 arg3 = static_cast< int >(val3);
29186 }
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29201 PyObject *resultobj = 0;
29202 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29203 void *argp1 = 0 ;
29204 int res1 = 0 ;
29205 PyObject *swig_obj[1] ;
29206
29207 if (!args) SWIG_fail;
29208 swig_obj[0] = args;
29209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29212 }
29213 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 delete arg1;
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 resultobj = SWIG_Py_Void();
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj = 0;
29230 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29231 int arg2 ;
29232 int arg3 ;
29233 int arg4 ;
29234 void *argp1 = 0 ;
29235 int res1 = 0 ;
29236 int val2 ;
29237 int ecode2 = 0 ;
29238 int val3 ;
29239 int ecode3 = 0 ;
29240 int val4 ;
29241 int ecode4 = 0 ;
29242 PyObject * obj0 = 0 ;
29243 PyObject * obj1 = 0 ;
29244 PyObject * obj2 = 0 ;
29245 PyObject * obj3 = 0 ;
29246 char * kwnames[] = {
29247 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29248 };
29249
29250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29252 if (!SWIG_IsOK(res1)) {
29253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29254 }
29255 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29256 ecode2 = SWIG_AsVal_int(obj1, &val2);
29257 if (!SWIG_IsOK(ecode2)) {
29258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29259 }
29260 arg2 = static_cast< int >(val2);
29261 ecode3 = SWIG_AsVal_int(obj2, &val3);
29262 if (!SWIG_IsOK(ecode3)) {
29263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29264 }
29265 arg3 = static_cast< int >(val3);
29266 ecode4 = SWIG_AsVal_int(obj3, &val4);
29267 if (!SWIG_IsOK(ecode4)) {
29268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29269 }
29270 arg4 = static_cast< int >(val4);
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 (arg1)->Set(arg2,arg3,arg4);
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 resultobj = SWIG_Py_Void();
29278 return resultobj;
29279 fail:
29280 return NULL;
29281 }
29282
29283
29284 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29285 PyObject *resultobj = 0;
29286 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29287 int result;
29288 void *argp1 = 0 ;
29289 int res1 = 0 ;
29290 PyObject *swig_obj[1] ;
29291
29292 if (!args) SWIG_fail;
29293 swig_obj[0] = args;
29294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29295 if (!SWIG_IsOK(res1)) {
29296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29297 }
29298 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29299 {
29300 PyThreadState* __tstate = wxPyBeginAllowThreads();
29301 result = (int)(arg1)->GetFlags();
29302 wxPyEndAllowThreads(__tstate);
29303 if (PyErr_Occurred()) SWIG_fail;
29304 }
29305 resultobj = SWIG_From_int(static_cast< int >(result));
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29313 PyObject *resultobj = 0;
29314 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29315 int result;
29316 void *argp1 = 0 ;
29317 int res1 = 0 ;
29318 PyObject *swig_obj[1] ;
29319
29320 if (!args) SWIG_fail;
29321 swig_obj[0] = args;
29322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29323 if (!SWIG_IsOK(res1)) {
29324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29325 }
29326 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29327 {
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = (int)(arg1)->GetKeyCode();
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 resultobj = SWIG_From_int(static_cast< int >(result));
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29341 PyObject *resultobj = 0;
29342 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29343 int result;
29344 void *argp1 = 0 ;
29345 int res1 = 0 ;
29346 PyObject *swig_obj[1] ;
29347
29348 if (!args) SWIG_fail;
29349 swig_obj[0] = args;
29350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29351 if (!SWIG_IsOK(res1)) {
29352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29353 }
29354 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 result = (int)(arg1)->GetCommand();
29358 wxPyEndAllowThreads(__tstate);
29359 if (PyErr_Occurred()) SWIG_fail;
29360 }
29361 resultobj = SWIG_From_int(static_cast< int >(result));
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29369 PyObject *obj;
29370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29371 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29372 return SWIG_Py_Void();
29373 }
29374
29375 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29376 return SWIG_Python_InitShadowInstance(args);
29377 }
29378
29379 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj = 0;
29381 int arg1 ;
29382 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29383 wxAcceleratorTable *result = 0 ;
29384 PyObject * obj0 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "n", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29390 {
29391 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29392 if (arg2) arg1 = PyList_Size(obj0);
29393 else arg1 = 0;
29394 }
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29402 return resultobj;
29403 fail:
29404 return NULL;
29405 }
29406
29407
29408 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29409 PyObject *resultobj = 0;
29410 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29411 void *argp1 = 0 ;
29412 int res1 = 0 ;
29413 PyObject *swig_obj[1] ;
29414
29415 if (!args) SWIG_fail;
29416 swig_obj[0] = args;
29417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29418 if (!SWIG_IsOK(res1)) {
29419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29420 }
29421 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29422 {
29423 PyThreadState* __tstate = wxPyBeginAllowThreads();
29424 delete arg1;
29425
29426 wxPyEndAllowThreads(__tstate);
29427 if (PyErr_Occurred()) SWIG_fail;
29428 }
29429 resultobj = SWIG_Py_Void();
29430 return resultobj;
29431 fail:
29432 return NULL;
29433 }
29434
29435
29436 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29437 PyObject *resultobj = 0;
29438 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29439 bool result;
29440 void *argp1 = 0 ;
29441 int res1 = 0 ;
29442 PyObject *swig_obj[1] ;
29443
29444 if (!args) SWIG_fail;
29445 swig_obj[0] = args;
29446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29447 if (!SWIG_IsOK(res1)) {
29448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29449 }
29450 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29451 {
29452 PyThreadState* __tstate = wxPyBeginAllowThreads();
29453 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29454 wxPyEndAllowThreads(__tstate);
29455 if (PyErr_Occurred()) SWIG_fail;
29456 }
29457 {
29458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29459 }
29460 return resultobj;
29461 fail:
29462 return NULL;
29463 }
29464
29465
29466 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29467 PyObject *obj;
29468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29469 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29470 return SWIG_Py_Void();
29471 }
29472
29473 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 return SWIG_Python_InitShadowInstance(args);
29475 }
29476
29477 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29478 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29479 return 1;
29480 }
29481
29482
29483 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29484 PyObject *pyobj = 0;
29485
29486 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29487 return pyobj;
29488 }
29489
29490
29491 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29492 PyObject *resultobj = 0;
29493 wxString *arg1 = 0 ;
29494 wxAcceleratorEntry *result = 0 ;
29495 bool temp1 = false ;
29496 PyObject * obj0 = 0 ;
29497 char * kwnames[] = {
29498 (char *) "label", NULL
29499 };
29500
29501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29502 {
29503 arg1 = wxString_in_helper(obj0);
29504 if (arg1 == NULL) SWIG_fail;
29505 temp1 = true;
29506 }
29507 {
29508 PyThreadState* __tstate = wxPyBeginAllowThreads();
29509 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29514 {
29515 if (temp1)
29516 delete arg1;
29517 }
29518 return resultobj;
29519 fail:
29520 {
29521 if (temp1)
29522 delete arg1;
29523 }
29524 return NULL;
29525 }
29526
29527
29528 SWIGINTERN int PanelNameStr_set(PyObject *) {
29529 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29530 return 1;
29531 }
29532
29533
29534 SWIGINTERN PyObject *PanelNameStr_get(void) {
29535 PyObject *pyobj = 0;
29536
29537 {
29538 #if wxUSE_UNICODE
29539 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29540 #else
29541 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29542 #endif
29543 }
29544 return pyobj;
29545 }
29546
29547
29548 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29549 PyObject *resultobj = 0;
29550 wxVisualAttributes *result = 0 ;
29551
29552 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (wxVisualAttributes *)new_wxVisualAttributes();
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29560 return resultobj;
29561 fail:
29562 return NULL;
29563 }
29564
29565
29566 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29567 PyObject *resultobj = 0;
29568 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29569 void *argp1 = 0 ;
29570 int res1 = 0 ;
29571 PyObject *swig_obj[1] ;
29572
29573 if (!args) SWIG_fail;
29574 swig_obj[0] = args;
29575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29576 if (!SWIG_IsOK(res1)) {
29577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29578 }
29579 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29580 {
29581 PyThreadState* __tstate = wxPyBeginAllowThreads();
29582 delete_wxVisualAttributes(arg1);
29583
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 resultobj = SWIG_Py_Void();
29588 return resultobj;
29589 fail:
29590 return NULL;
29591 }
29592
29593
29594 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29595 PyObject *resultobj = 0;
29596 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29597 wxFont *arg2 = (wxFont *) 0 ;
29598 void *argp1 = 0 ;
29599 int res1 = 0 ;
29600 void *argp2 = 0 ;
29601 int res2 = 0 ;
29602 PyObject *swig_obj[2] ;
29603
29604 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29606 if (!SWIG_IsOK(res1)) {
29607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29608 }
29609 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29610 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29611 if (!SWIG_IsOK(res2)) {
29612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29613 }
29614 arg2 = reinterpret_cast< wxFont * >(argp2);
29615 if (arg1) (arg1)->font = *arg2;
29616
29617 resultobj = SWIG_Py_Void();
29618 return resultobj;
29619 fail:
29620 return NULL;
29621 }
29622
29623
29624 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29625 PyObject *resultobj = 0;
29626 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29627 wxFont *result = 0 ;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 PyObject *swig_obj[1] ;
29631
29632 if (!args) SWIG_fail;
29633 swig_obj[0] = args;
29634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29635 if (!SWIG_IsOK(res1)) {
29636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29637 }
29638 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29639 result = (wxFont *)& ((arg1)->font);
29640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29641 return resultobj;
29642 fail:
29643 return NULL;
29644 }
29645
29646
29647 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29648 PyObject *resultobj = 0;
29649 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29650 wxColour *arg2 = (wxColour *) 0 ;
29651 void *argp1 = 0 ;
29652 int res1 = 0 ;
29653 void *argp2 = 0 ;
29654 int res2 = 0 ;
29655 PyObject *swig_obj[2] ;
29656
29657 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29659 if (!SWIG_IsOK(res1)) {
29660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29661 }
29662 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29663 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29664 if (!SWIG_IsOK(res2)) {
29665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29666 }
29667 arg2 = reinterpret_cast< wxColour * >(argp2);
29668 if (arg1) (arg1)->colFg = *arg2;
29669
29670 resultobj = SWIG_Py_Void();
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29678 PyObject *resultobj = 0;
29679 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29680 wxColour *result = 0 ;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 PyObject *swig_obj[1] ;
29684
29685 if (!args) SWIG_fail;
29686 swig_obj[0] = args;
29687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29690 }
29691 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29692 result = (wxColour *)& ((arg1)->colFg);
29693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 PyObject *resultobj = 0;
29702 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29703 wxColour *arg2 = (wxColour *) 0 ;
29704 void *argp1 = 0 ;
29705 int res1 = 0 ;
29706 void *argp2 = 0 ;
29707 int res2 = 0 ;
29708 PyObject *swig_obj[2] ;
29709
29710 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29712 if (!SWIG_IsOK(res1)) {
29713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29714 }
29715 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29716 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29717 if (!SWIG_IsOK(res2)) {
29718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29719 }
29720 arg2 = reinterpret_cast< wxColour * >(argp2);
29721 if (arg1) (arg1)->colBg = *arg2;
29722
29723 resultobj = SWIG_Py_Void();
29724 return resultobj;
29725 fail:
29726 return NULL;
29727 }
29728
29729
29730 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29731 PyObject *resultobj = 0;
29732 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29733 wxColour *result = 0 ;
29734 void *argp1 = 0 ;
29735 int res1 = 0 ;
29736 PyObject *swig_obj[1] ;
29737
29738 if (!args) SWIG_fail;
29739 swig_obj[0] = args;
29740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29741 if (!SWIG_IsOK(res1)) {
29742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29743 }
29744 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29745 result = (wxColour *)& ((arg1)->colBg);
29746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29747 return resultobj;
29748 fail:
29749 return NULL;
29750 }
29751
29752
29753 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29754 PyObject *obj;
29755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29756 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29757 return SWIG_Py_Void();
29758 }
29759
29760 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29761 return SWIG_Python_InitShadowInstance(args);
29762 }
29763
29764 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj = 0;
29766 wxWindow *arg1 = (wxWindow *) 0 ;
29767 int arg2 = (int) (int)-1 ;
29768 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29769 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29770 wxSize const &arg4_defvalue = wxDefaultSize ;
29771 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29772 long arg5 = (long) 0 ;
29773 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29774 wxString *arg6 = (wxString *) &arg6_defvalue ;
29775 wxWindow *result = 0 ;
29776 void *argp1 = 0 ;
29777 int res1 = 0 ;
29778 int val2 ;
29779 int ecode2 = 0 ;
29780 wxPoint temp3 ;
29781 wxSize temp4 ;
29782 long val5 ;
29783 int ecode5 = 0 ;
29784 bool temp6 = false ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 PyObject * obj2 = 0 ;
29788 PyObject * obj3 = 0 ;
29789 PyObject * obj4 = 0 ;
29790 PyObject * obj5 = 0 ;
29791 char * kwnames[] = {
29792 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29793 };
29794
29795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29797 if (!SWIG_IsOK(res1)) {
29798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29799 }
29800 arg1 = reinterpret_cast< wxWindow * >(argp1);
29801 if (obj1) {
29802 ecode2 = SWIG_AsVal_int(obj1, &val2);
29803 if (!SWIG_IsOK(ecode2)) {
29804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29805 }
29806 arg2 = static_cast< int >(val2);
29807 }
29808 if (obj2) {
29809 {
29810 arg3 = &temp3;
29811 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29812 }
29813 }
29814 if (obj3) {
29815 {
29816 arg4 = &temp4;
29817 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29818 }
29819 }
29820 if (obj4) {
29821 ecode5 = SWIG_AsVal_long(obj4, &val5);
29822 if (!SWIG_IsOK(ecode5)) {
29823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29824 }
29825 arg5 = static_cast< long >(val5);
29826 }
29827 if (obj5) {
29828 {
29829 arg6 = wxString_in_helper(obj5);
29830 if (arg6 == NULL) SWIG_fail;
29831 temp6 = true;
29832 }
29833 }
29834 {
29835 if (!wxPyCheckForApp()) SWIG_fail;
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29838 wxPyEndAllowThreads(__tstate);
29839 if (PyErr_Occurred()) SWIG_fail;
29840 }
29841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29842 {
29843 if (temp6)
29844 delete arg6;
29845 }
29846 return resultobj;
29847 fail:
29848 {
29849 if (temp6)
29850 delete arg6;
29851 }
29852 return NULL;
29853 }
29854
29855
29856 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29857 PyObject *resultobj = 0;
29858 wxWindow *result = 0 ;
29859
29860 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29861 {
29862 if (!wxPyCheckForApp()) SWIG_fail;
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (wxWindow *)new wxWindow();
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj = 0;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 wxWindow *arg2 = (wxWindow *) 0 ;
29879 int arg3 = (int) (int)-1 ;
29880 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29881 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29882 wxSize const &arg5_defvalue = wxDefaultSize ;
29883 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29884 long arg6 = (long) 0 ;
29885 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29886 wxString *arg7 = (wxString *) &arg7_defvalue ;
29887 bool result;
29888 void *argp1 = 0 ;
29889 int res1 = 0 ;
29890 void *argp2 = 0 ;
29891 int res2 = 0 ;
29892 int val3 ;
29893 int ecode3 = 0 ;
29894 wxPoint temp4 ;
29895 wxSize temp5 ;
29896 long val6 ;
29897 int ecode6 = 0 ;
29898 bool temp7 = false ;
29899 PyObject * obj0 = 0 ;
29900 PyObject * obj1 = 0 ;
29901 PyObject * obj2 = 0 ;
29902 PyObject * obj3 = 0 ;
29903 PyObject * obj4 = 0 ;
29904 PyObject * obj5 = 0 ;
29905 PyObject * obj6 = 0 ;
29906 char * kwnames[] = {
29907 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29908 };
29909
29910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29912 if (!SWIG_IsOK(res1)) {
29913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29914 }
29915 arg1 = reinterpret_cast< wxWindow * >(argp1);
29916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29917 if (!SWIG_IsOK(res2)) {
29918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29919 }
29920 arg2 = reinterpret_cast< wxWindow * >(argp2);
29921 if (obj2) {
29922 ecode3 = SWIG_AsVal_int(obj2, &val3);
29923 if (!SWIG_IsOK(ecode3)) {
29924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29925 }
29926 arg3 = static_cast< int >(val3);
29927 }
29928 if (obj3) {
29929 {
29930 arg4 = &temp4;
29931 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29932 }
29933 }
29934 if (obj4) {
29935 {
29936 arg5 = &temp5;
29937 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29938 }
29939 }
29940 if (obj5) {
29941 ecode6 = SWIG_AsVal_long(obj5, &val6);
29942 if (!SWIG_IsOK(ecode6)) {
29943 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29944 }
29945 arg6 = static_cast< long >(val6);
29946 }
29947 if (obj6) {
29948 {
29949 arg7 = wxString_in_helper(obj6);
29950 if (arg7 == NULL) SWIG_fail;
29951 temp7 = true;
29952 }
29953 }
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29957 wxPyEndAllowThreads(__tstate);
29958 if (PyErr_Occurred()) SWIG_fail;
29959 }
29960 {
29961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29962 }
29963 {
29964 if (temp7)
29965 delete arg7;
29966 }
29967 return resultobj;
29968 fail:
29969 {
29970 if (temp7)
29971 delete arg7;
29972 }
29973 return NULL;
29974 }
29975
29976
29977 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29978 PyObject *resultobj = 0;
29979 wxWindow *arg1 = (wxWindow *) 0 ;
29980 bool arg2 = (bool) false ;
29981 bool result;
29982 void *argp1 = 0 ;
29983 int res1 = 0 ;
29984 bool val2 ;
29985 int ecode2 = 0 ;
29986 PyObject * obj0 = 0 ;
29987 PyObject * obj1 = 0 ;
29988 char * kwnames[] = {
29989 (char *) "self",(char *) "force", NULL
29990 };
29991
29992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29994 if (!SWIG_IsOK(res1)) {
29995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29996 }
29997 arg1 = reinterpret_cast< wxWindow * >(argp1);
29998 if (obj1) {
29999 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30000 if (!SWIG_IsOK(ecode2)) {
30001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30002 }
30003 arg2 = static_cast< bool >(val2);
30004 }
30005 {
30006 PyThreadState* __tstate = wxPyBeginAllowThreads();
30007 result = (bool)(arg1)->Close(arg2);
30008 wxPyEndAllowThreads(__tstate);
30009 if (PyErr_Occurred()) SWIG_fail;
30010 }
30011 {
30012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30013 }
30014 return resultobj;
30015 fail:
30016 return NULL;
30017 }
30018
30019
30020 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30021 PyObject *resultobj = 0;
30022 wxWindow *arg1 = (wxWindow *) 0 ;
30023 bool result;
30024 void *argp1 = 0 ;
30025 int res1 = 0 ;
30026 PyObject *swig_obj[1] ;
30027
30028 if (!args) SWIG_fail;
30029 swig_obj[0] = args;
30030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30031 if (!SWIG_IsOK(res1)) {
30032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30033 }
30034 arg1 = reinterpret_cast< wxWindow * >(argp1);
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 result = (bool)(arg1)->Destroy();
30038 wxPyEndAllowThreads(__tstate);
30039 if (PyErr_Occurred()) SWIG_fail;
30040 }
30041 {
30042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30043 }
30044 return resultobj;
30045 fail:
30046 return NULL;
30047 }
30048
30049
30050 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30051 PyObject *resultobj = 0;
30052 wxWindow *arg1 = (wxWindow *) 0 ;
30053 bool result;
30054 void *argp1 = 0 ;
30055 int res1 = 0 ;
30056 PyObject *swig_obj[1] ;
30057
30058 if (!args) SWIG_fail;
30059 swig_obj[0] = args;
30060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30061 if (!SWIG_IsOK(res1)) {
30062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30063 }
30064 arg1 = reinterpret_cast< wxWindow * >(argp1);
30065 {
30066 PyThreadState* __tstate = wxPyBeginAllowThreads();
30067 result = (bool)(arg1)->DestroyChildren();
30068 wxPyEndAllowThreads(__tstate);
30069 if (PyErr_Occurred()) SWIG_fail;
30070 }
30071 {
30072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30073 }
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30081 PyObject *resultobj = 0;
30082 wxWindow *arg1 = (wxWindow *) 0 ;
30083 bool result;
30084 void *argp1 = 0 ;
30085 int res1 = 0 ;
30086 PyObject *swig_obj[1] ;
30087
30088 if (!args) SWIG_fail;
30089 swig_obj[0] = args;
30090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30091 if (!SWIG_IsOK(res1)) {
30092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30093 }
30094 arg1 = reinterpret_cast< wxWindow * >(argp1);
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 {
30102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30103 }
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30111 PyObject *resultobj = 0;
30112 wxWindow *arg1 = (wxWindow *) 0 ;
30113 wxString *arg2 = 0 ;
30114 void *argp1 = 0 ;
30115 int res1 = 0 ;
30116 bool temp2 = false ;
30117 PyObject * obj0 = 0 ;
30118 PyObject * obj1 = 0 ;
30119 char * kwnames[] = {
30120 (char *) "self",(char *) "label", NULL
30121 };
30122
30123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30125 if (!SWIG_IsOK(res1)) {
30126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30127 }
30128 arg1 = reinterpret_cast< wxWindow * >(argp1);
30129 {
30130 arg2 = wxString_in_helper(obj1);
30131 if (arg2 == NULL) SWIG_fail;
30132 temp2 = true;
30133 }
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 (arg1)->SetLabel((wxString const &)*arg2);
30137 wxPyEndAllowThreads(__tstate);
30138 if (PyErr_Occurred()) SWIG_fail;
30139 }
30140 resultobj = SWIG_Py_Void();
30141 {
30142 if (temp2)
30143 delete arg2;
30144 }
30145 return resultobj;
30146 fail:
30147 {
30148 if (temp2)
30149 delete arg2;
30150 }
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30156 PyObject *resultobj = 0;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 wxString result;
30159 void *argp1 = 0 ;
30160 int res1 = 0 ;
30161 PyObject *swig_obj[1] ;
30162
30163 if (!args) SWIG_fail;
30164 swig_obj[0] = args;
30165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30168 }
30169 arg1 = reinterpret_cast< wxWindow * >(argp1);
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = ((wxWindow const *)arg1)->GetLabel();
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 {
30177 #if wxUSE_UNICODE
30178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30179 #else
30180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30181 #endif
30182 }
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj = 0;
30191 wxWindow *arg1 = (wxWindow *) 0 ;
30192 wxString *arg2 = 0 ;
30193 void *argp1 = 0 ;
30194 int res1 = 0 ;
30195 bool temp2 = false ;
30196 PyObject * obj0 = 0 ;
30197 PyObject * obj1 = 0 ;
30198 char * kwnames[] = {
30199 (char *) "self",(char *) "name", NULL
30200 };
30201
30202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30204 if (!SWIG_IsOK(res1)) {
30205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30206 }
30207 arg1 = reinterpret_cast< wxWindow * >(argp1);
30208 {
30209 arg2 = wxString_in_helper(obj1);
30210 if (arg2 == NULL) SWIG_fail;
30211 temp2 = true;
30212 }
30213 {
30214 PyThreadState* __tstate = wxPyBeginAllowThreads();
30215 (arg1)->SetName((wxString const &)*arg2);
30216 wxPyEndAllowThreads(__tstate);
30217 if (PyErr_Occurred()) SWIG_fail;
30218 }
30219 resultobj = SWIG_Py_Void();
30220 {
30221 if (temp2)
30222 delete arg2;
30223 }
30224 return resultobj;
30225 fail:
30226 {
30227 if (temp2)
30228 delete arg2;
30229 }
30230 return NULL;
30231 }
30232
30233
30234 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30235 PyObject *resultobj = 0;
30236 wxWindow *arg1 = (wxWindow *) 0 ;
30237 wxString result;
30238 void *argp1 = 0 ;
30239 int res1 = 0 ;
30240 PyObject *swig_obj[1] ;
30241
30242 if (!args) SWIG_fail;
30243 swig_obj[0] = args;
30244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30245 if (!SWIG_IsOK(res1)) {
30246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30247 }
30248 arg1 = reinterpret_cast< wxWindow * >(argp1);
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 result = ((wxWindow const *)arg1)->GetName();
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 {
30256 #if wxUSE_UNICODE
30257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30258 #else
30259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30260 #endif
30261 }
30262 return resultobj;
30263 fail:
30264 return NULL;
30265 }
30266
30267
30268 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxWindow *arg1 = (wxWindow *) 0 ;
30271 wxWindowVariant arg2 ;
30272 void *argp1 = 0 ;
30273 int res1 = 0 ;
30274 int val2 ;
30275 int ecode2 = 0 ;
30276 PyObject * obj0 = 0 ;
30277 PyObject * obj1 = 0 ;
30278 char * kwnames[] = {
30279 (char *) "self",(char *) "variant", NULL
30280 };
30281
30282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30284 if (!SWIG_IsOK(res1)) {
30285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30286 }
30287 arg1 = reinterpret_cast< wxWindow * >(argp1);
30288 ecode2 = SWIG_AsVal_int(obj1, &val2);
30289 if (!SWIG_IsOK(ecode2)) {
30290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30291 }
30292 arg2 = static_cast< wxWindowVariant >(val2);
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 (arg1)->SetWindowVariant(arg2);
30296 wxPyEndAllowThreads(__tstate);
30297 if (PyErr_Occurred()) SWIG_fail;
30298 }
30299 resultobj = SWIG_Py_Void();
30300 return resultobj;
30301 fail:
30302 return NULL;
30303 }
30304
30305
30306 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30307 PyObject *resultobj = 0;
30308 wxWindow *arg1 = (wxWindow *) 0 ;
30309 wxWindowVariant result;
30310 void *argp1 = 0 ;
30311 int res1 = 0 ;
30312 PyObject *swig_obj[1] ;
30313
30314 if (!args) SWIG_fail;
30315 swig_obj[0] = args;
30316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30317 if (!SWIG_IsOK(res1)) {
30318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30319 }
30320 arg1 = reinterpret_cast< wxWindow * >(argp1);
30321 {
30322 PyThreadState* __tstate = wxPyBeginAllowThreads();
30323 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30324 wxPyEndAllowThreads(__tstate);
30325 if (PyErr_Occurred()) SWIG_fail;
30326 }
30327 resultobj = SWIG_From_int(static_cast< int >(result));
30328 return resultobj;
30329 fail:
30330 return NULL;
30331 }
30332
30333
30334 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30335 PyObject *resultobj = 0;
30336 wxWindow *arg1 = (wxWindow *) 0 ;
30337 int arg2 ;
30338 void *argp1 = 0 ;
30339 int res1 = 0 ;
30340 int val2 ;
30341 int ecode2 = 0 ;
30342 PyObject * obj0 = 0 ;
30343 PyObject * obj1 = 0 ;
30344 char * kwnames[] = {
30345 (char *) "self",(char *) "winid", NULL
30346 };
30347
30348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30350 if (!SWIG_IsOK(res1)) {
30351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30352 }
30353 arg1 = reinterpret_cast< wxWindow * >(argp1);
30354 ecode2 = SWIG_AsVal_int(obj1, &val2);
30355 if (!SWIG_IsOK(ecode2)) {
30356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30357 }
30358 arg2 = static_cast< int >(val2);
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 (arg1)->SetId(arg2);
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_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30373 PyObject *resultobj = 0;
30374 wxWindow *arg1 = (wxWindow *) 0 ;
30375 int result;
30376 void *argp1 = 0 ;
30377 int res1 = 0 ;
30378 PyObject *swig_obj[1] ;
30379
30380 if (!args) SWIG_fail;
30381 swig_obj[0] = args;
30382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30383 if (!SWIG_IsOK(res1)) {
30384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30385 }
30386 arg1 = reinterpret_cast< wxWindow * >(argp1);
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (int)((wxWindow const *)arg1)->GetId();
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 resultobj = SWIG_From_int(static_cast< int >(result));
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30401 PyObject *resultobj = 0;
30402 int result;
30403
30404 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 result = (int)wxWindow::NewControlId();
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 resultobj = SWIG_From_int(static_cast< int >(result));
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30419 PyObject *resultobj = 0;
30420 int arg1 ;
30421 int result;
30422 int val1 ;
30423 int ecode1 = 0 ;
30424 PyObject * obj0 = 0 ;
30425 char * kwnames[] = {
30426 (char *) "winid", NULL
30427 };
30428
30429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30430 ecode1 = SWIG_AsVal_int(obj0, &val1);
30431 if (!SWIG_IsOK(ecode1)) {
30432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30433 }
30434 arg1 = static_cast< int >(val1);
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (int)wxWindow::NextControlId(arg1);
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 resultobj = SWIG_From_int(static_cast< int >(result));
30442 return resultobj;
30443 fail:
30444 return NULL;
30445 }
30446
30447
30448 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30449 PyObject *resultobj = 0;
30450 int arg1 ;
30451 int result;
30452 int val1 ;
30453 int ecode1 = 0 ;
30454 PyObject * obj0 = 0 ;
30455 char * kwnames[] = {
30456 (char *) "winid", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30460 ecode1 = SWIG_AsVal_int(obj0, &val1);
30461 if (!SWIG_IsOK(ecode1)) {
30462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30463 }
30464 arg1 = static_cast< int >(val1);
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 result = (int)wxWindow::PrevControlId(arg1);
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 resultobj = SWIG_From_int(static_cast< int >(result));
30472 return resultobj;
30473 fail:
30474 return NULL;
30475 }
30476
30477
30478 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30479 PyObject *resultobj = 0;
30480 wxWindow *arg1 = (wxWindow *) 0 ;
30481 wxSize *arg2 = 0 ;
30482 void *argp1 = 0 ;
30483 int res1 = 0 ;
30484 wxSize temp2 ;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 char * kwnames[] = {
30488 (char *) "self",(char *) "size", NULL
30489 };
30490
30491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30493 if (!SWIG_IsOK(res1)) {
30494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30495 }
30496 arg1 = reinterpret_cast< wxWindow * >(argp1);
30497 {
30498 arg2 = &temp2;
30499 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30500 }
30501 {
30502 PyThreadState* __tstate = wxPyBeginAllowThreads();
30503 (arg1)->SetSize((wxSize const &)*arg2);
30504 wxPyEndAllowThreads(__tstate);
30505 if (PyErr_Occurred()) SWIG_fail;
30506 }
30507 resultobj = SWIG_Py_Void();
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj = 0;
30516 wxWindow *arg1 = (wxWindow *) 0 ;
30517 int arg2 ;
30518 int arg3 ;
30519 int arg4 ;
30520 int arg5 ;
30521 int arg6 = (int) wxSIZE_AUTO ;
30522 void *argp1 = 0 ;
30523 int res1 = 0 ;
30524 int val2 ;
30525 int ecode2 = 0 ;
30526 int val3 ;
30527 int ecode3 = 0 ;
30528 int val4 ;
30529 int ecode4 = 0 ;
30530 int val5 ;
30531 int ecode5 = 0 ;
30532 int val6 ;
30533 int ecode6 = 0 ;
30534 PyObject * obj0 = 0 ;
30535 PyObject * obj1 = 0 ;
30536 PyObject * obj2 = 0 ;
30537 PyObject * obj3 = 0 ;
30538 PyObject * obj4 = 0 ;
30539 PyObject * obj5 = 0 ;
30540 char * kwnames[] = {
30541 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30542 };
30543
30544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30546 if (!SWIG_IsOK(res1)) {
30547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30548 }
30549 arg1 = reinterpret_cast< wxWindow * >(argp1);
30550 ecode2 = SWIG_AsVal_int(obj1, &val2);
30551 if (!SWIG_IsOK(ecode2)) {
30552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30553 }
30554 arg2 = static_cast< int >(val2);
30555 ecode3 = SWIG_AsVal_int(obj2, &val3);
30556 if (!SWIG_IsOK(ecode3)) {
30557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30558 }
30559 arg3 = static_cast< int >(val3);
30560 ecode4 = SWIG_AsVal_int(obj3, &val4);
30561 if (!SWIG_IsOK(ecode4)) {
30562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30563 }
30564 arg4 = static_cast< int >(val4);
30565 ecode5 = SWIG_AsVal_int(obj4, &val5);
30566 if (!SWIG_IsOK(ecode5)) {
30567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30568 }
30569 arg5 = static_cast< int >(val5);
30570 if (obj5) {
30571 ecode6 = SWIG_AsVal_int(obj5, &val6);
30572 if (!SWIG_IsOK(ecode6)) {
30573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30574 }
30575 arg6 = static_cast< int >(val6);
30576 }
30577 {
30578 PyThreadState* __tstate = wxPyBeginAllowThreads();
30579 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30580 wxPyEndAllowThreads(__tstate);
30581 if (PyErr_Occurred()) SWIG_fail;
30582 }
30583 resultobj = SWIG_Py_Void();
30584 return resultobj;
30585 fail:
30586 return NULL;
30587 }
30588
30589
30590 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30591 PyObject *resultobj = 0;
30592 wxWindow *arg1 = (wxWindow *) 0 ;
30593 wxRect *arg2 = 0 ;
30594 int arg3 = (int) wxSIZE_AUTO ;
30595 void *argp1 = 0 ;
30596 int res1 = 0 ;
30597 wxRect temp2 ;
30598 int val3 ;
30599 int ecode3 = 0 ;
30600 PyObject * obj0 = 0 ;
30601 PyObject * obj1 = 0 ;
30602 PyObject * obj2 = 0 ;
30603 char * kwnames[] = {
30604 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30605 };
30606
30607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30609 if (!SWIG_IsOK(res1)) {
30610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30611 }
30612 arg1 = reinterpret_cast< wxWindow * >(argp1);
30613 {
30614 arg2 = &temp2;
30615 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30616 }
30617 if (obj2) {
30618 ecode3 = SWIG_AsVal_int(obj2, &val3);
30619 if (!SWIG_IsOK(ecode3)) {
30620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30621 }
30622 arg3 = static_cast< int >(val3);
30623 }
30624 {
30625 PyThreadState* __tstate = wxPyBeginAllowThreads();
30626 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_Py_Void();
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj = 0;
30639 wxWindow *arg1 = (wxWindow *) 0 ;
30640 int arg2 ;
30641 int arg3 ;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 int val2 ;
30645 int ecode2 = 0 ;
30646 int val3 ;
30647 int ecode3 = 0 ;
30648 PyObject * obj0 = 0 ;
30649 PyObject * obj1 = 0 ;
30650 PyObject * obj2 = 0 ;
30651 char * kwnames[] = {
30652 (char *) "self",(char *) "width",(char *) "height", NULL
30653 };
30654
30655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30657 if (!SWIG_IsOK(res1)) {
30658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30659 }
30660 arg1 = reinterpret_cast< wxWindow * >(argp1);
30661 ecode2 = SWIG_AsVal_int(obj1, &val2);
30662 if (!SWIG_IsOK(ecode2)) {
30663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30664 }
30665 arg2 = static_cast< int >(val2);
30666 ecode3 = SWIG_AsVal_int(obj2, &val3);
30667 if (!SWIG_IsOK(ecode3)) {
30668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30669 }
30670 arg3 = static_cast< int >(val3);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 (arg1)->SetSize(arg2,arg3);
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_Py_Void();
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30685 PyObject *resultobj = 0;
30686 wxWindow *arg1 = (wxWindow *) 0 ;
30687 wxPoint *arg2 = 0 ;
30688 int arg3 = (int) wxSIZE_USE_EXISTING ;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 wxPoint temp2 ;
30692 int val3 ;
30693 int ecode3 = 0 ;
30694 PyObject * obj0 = 0 ;
30695 PyObject * obj1 = 0 ;
30696 PyObject * obj2 = 0 ;
30697 char * kwnames[] = {
30698 (char *) "self",(char *) "pt",(char *) "flags", NULL
30699 };
30700
30701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30703 if (!SWIG_IsOK(res1)) {
30704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30705 }
30706 arg1 = reinterpret_cast< wxWindow * >(argp1);
30707 {
30708 arg2 = &temp2;
30709 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30710 }
30711 if (obj2) {
30712 ecode3 = SWIG_AsVal_int(obj2, &val3);
30713 if (!SWIG_IsOK(ecode3)) {
30714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30715 }
30716 arg3 = static_cast< int >(val3);
30717 }
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 (arg1)->Move((wxPoint const &)*arg2,arg3);
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 resultobj = SWIG_Py_Void();
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30732 PyObject *resultobj = 0;
30733 wxWindow *arg1 = (wxWindow *) 0 ;
30734 int arg2 ;
30735 int arg3 ;
30736 int arg4 = (int) wxSIZE_USE_EXISTING ;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 int val2 ;
30740 int ecode2 = 0 ;
30741 int val3 ;
30742 int ecode3 = 0 ;
30743 int val4 ;
30744 int ecode4 = 0 ;
30745 PyObject * obj0 = 0 ;
30746 PyObject * obj1 = 0 ;
30747 PyObject * obj2 = 0 ;
30748 PyObject * obj3 = 0 ;
30749 char * kwnames[] = {
30750 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30751 };
30752
30753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30755 if (!SWIG_IsOK(res1)) {
30756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30757 }
30758 arg1 = reinterpret_cast< wxWindow * >(argp1);
30759 ecode2 = SWIG_AsVal_int(obj1, &val2);
30760 if (!SWIG_IsOK(ecode2)) {
30761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30762 }
30763 arg2 = static_cast< int >(val2);
30764 ecode3 = SWIG_AsVal_int(obj2, &val3);
30765 if (!SWIG_IsOK(ecode3)) {
30766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30767 }
30768 arg3 = static_cast< int >(val3);
30769 if (obj3) {
30770 ecode4 = SWIG_AsVal_int(obj3, &val4);
30771 if (!SWIG_IsOK(ecode4)) {
30772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30773 }
30774 arg4 = static_cast< int >(val4);
30775 }
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 (arg1)->Move(arg2,arg3,arg4);
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_Py_Void();
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj = 0;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 wxSize const &arg2_defvalue = wxDefaultSize ;
30793 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30794 void *argp1 = 0 ;
30795 int res1 = 0 ;
30796 wxSize temp2 ;
30797 PyObject * obj0 = 0 ;
30798 PyObject * obj1 = 0 ;
30799 char * kwnames[] = {
30800 (char *) "self",(char *) "size", NULL
30801 };
30802
30803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30807 }
30808 arg1 = reinterpret_cast< wxWindow * >(argp1);
30809 if (obj1) {
30810 {
30811 arg2 = &temp2;
30812 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30813 }
30814 }
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_Py_Void();
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30829 PyObject *resultobj = 0;
30830 wxWindow *arg1 = (wxWindow *) 0 ;
30831 void *argp1 = 0 ;
30832 int res1 = 0 ;
30833 PyObject *swig_obj[1] ;
30834
30835 if (!args) SWIG_fail;
30836 swig_obj[0] = args;
30837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30838 if (!SWIG_IsOK(res1)) {
30839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30840 }
30841 arg1 = reinterpret_cast< wxWindow * >(argp1);
30842 {
30843 PyThreadState* __tstate = wxPyBeginAllowThreads();
30844 (arg1)->Raise();
30845 wxPyEndAllowThreads(__tstate);
30846 if (PyErr_Occurred()) SWIG_fail;
30847 }
30848 resultobj = SWIG_Py_Void();
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30856 PyObject *resultobj = 0;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 PyObject *swig_obj[1] ;
30861
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 (arg1)->Lower();
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 resultobj = SWIG_Py_Void();
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj = 0;
30884 wxWindow *arg1 = (wxWindow *) 0 ;
30885 wxSize *arg2 = 0 ;
30886 void *argp1 = 0 ;
30887 int res1 = 0 ;
30888 wxSize temp2 ;
30889 PyObject * obj0 = 0 ;
30890 PyObject * obj1 = 0 ;
30891 char * kwnames[] = {
30892 (char *) "self",(char *) "size", NULL
30893 };
30894
30895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30897 if (!SWIG_IsOK(res1)) {
30898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30899 }
30900 arg1 = reinterpret_cast< wxWindow * >(argp1);
30901 {
30902 arg2 = &temp2;
30903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30904 }
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 (arg1)->SetClientSize((wxSize const &)*arg2);
30908 wxPyEndAllowThreads(__tstate);
30909 if (PyErr_Occurred()) SWIG_fail;
30910 }
30911 resultobj = SWIG_Py_Void();
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30919 PyObject *resultobj = 0;
30920 wxWindow *arg1 = (wxWindow *) 0 ;
30921 int arg2 ;
30922 int arg3 ;
30923 void *argp1 = 0 ;
30924 int res1 = 0 ;
30925 int val2 ;
30926 int ecode2 = 0 ;
30927 int val3 ;
30928 int ecode3 = 0 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 PyObject * obj2 = 0 ;
30932 char * kwnames[] = {
30933 (char *) "self",(char *) "width",(char *) "height", NULL
30934 };
30935
30936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30938 if (!SWIG_IsOK(res1)) {
30939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30940 }
30941 arg1 = reinterpret_cast< wxWindow * >(argp1);
30942 ecode2 = SWIG_AsVal_int(obj1, &val2);
30943 if (!SWIG_IsOK(ecode2)) {
30944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30945 }
30946 arg2 = static_cast< int >(val2);
30947 ecode3 = SWIG_AsVal_int(obj2, &val3);
30948 if (!SWIG_IsOK(ecode3)) {
30949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30950 }
30951 arg3 = static_cast< int >(val3);
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 (arg1)->SetClientSize(arg2,arg3);
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_Py_Void();
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxRect *arg2 = 0 ;
30969 void *argp1 = 0 ;
30970 int res1 = 0 ;
30971 wxRect temp2 ;
30972 PyObject * obj0 = 0 ;
30973 PyObject * obj1 = 0 ;
30974 char * kwnames[] = {
30975 (char *) "self",(char *) "rect", NULL
30976 };
30977
30978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 arg2 = &temp2;
30986 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30987 }
30988 {
30989 PyThreadState* __tstate = wxPyBeginAllowThreads();
30990 (arg1)->SetClientSize((wxRect const &)*arg2);
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 resultobj = SWIG_Py_Void();
30995 return resultobj;
30996 fail:
30997 return NULL;
30998 }
30999
31000
31001 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31002 PyObject *resultobj = 0;
31003 wxWindow *arg1 = (wxWindow *) 0 ;
31004 wxPoint result;
31005 void *argp1 = 0 ;
31006 int res1 = 0 ;
31007 PyObject *swig_obj[1] ;
31008
31009 if (!args) SWIG_fail;
31010 swig_obj[0] = args;
31011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31012 if (!SWIG_IsOK(res1)) {
31013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31014 }
31015 arg1 = reinterpret_cast< wxWindow * >(argp1);
31016 {
31017 PyThreadState* __tstate = wxPyBeginAllowThreads();
31018 result = ((wxWindow const *)arg1)->GetPosition();
31019 wxPyEndAllowThreads(__tstate);
31020 if (PyErr_Occurred()) SWIG_fail;
31021 }
31022 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31030 PyObject *resultobj = 0;
31031 wxWindow *arg1 = (wxWindow *) 0 ;
31032 int *arg2 = (int *) 0 ;
31033 int *arg3 = (int *) 0 ;
31034 void *argp1 = 0 ;
31035 int res1 = 0 ;
31036 int temp2 ;
31037 int res2 = SWIG_TMPOBJ ;
31038 int temp3 ;
31039 int res3 = SWIG_TMPOBJ ;
31040 PyObject *swig_obj[1] ;
31041
31042 arg2 = &temp2;
31043 arg3 = &temp3;
31044 if (!args) SWIG_fail;
31045 swig_obj[0] = args;
31046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31047 if (!SWIG_IsOK(res1)) {
31048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31049 }
31050 arg1 = reinterpret_cast< wxWindow * >(argp1);
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_Py_Void();
31058 if (SWIG_IsTmpObj(res2)) {
31059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31060 } else {
31061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31063 }
31064 if (SWIG_IsTmpObj(res3)) {
31065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31066 } else {
31067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31069 }
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31077 PyObject *resultobj = 0;
31078 wxWindow *arg1 = (wxWindow *) 0 ;
31079 wxPoint result;
31080 void *argp1 = 0 ;
31081 int res1 = 0 ;
31082 PyObject *swig_obj[1] ;
31083
31084 if (!args) SWIG_fail;
31085 swig_obj[0] = args;
31086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31087 if (!SWIG_IsOK(res1)) {
31088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31089 }
31090 arg1 = reinterpret_cast< wxWindow * >(argp1);
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 result = ((wxWindow const *)arg1)->GetScreenPosition();
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31098 return resultobj;
31099 fail:
31100 return NULL;
31101 }
31102
31103
31104 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31105 PyObject *resultobj = 0;
31106 wxWindow *arg1 = (wxWindow *) 0 ;
31107 int *arg2 = (int *) 0 ;
31108 int *arg3 = (int *) 0 ;
31109 void *argp1 = 0 ;
31110 int res1 = 0 ;
31111 int temp2 ;
31112 int res2 = SWIG_TMPOBJ ;
31113 int temp3 ;
31114 int res3 = SWIG_TMPOBJ ;
31115 PyObject *swig_obj[1] ;
31116
31117 arg2 = &temp2;
31118 arg3 = &temp3;
31119 if (!args) SWIG_fail;
31120 swig_obj[0] = args;
31121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31122 if (!SWIG_IsOK(res1)) {
31123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31124 }
31125 arg1 = reinterpret_cast< wxWindow * >(argp1);
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_Py_Void();
31133 if (SWIG_IsTmpObj(res2)) {
31134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31135 } else {
31136 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31138 }
31139 if (SWIG_IsTmpObj(res3)) {
31140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31141 } else {
31142 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31144 }
31145 return resultobj;
31146 fail:
31147 return NULL;
31148 }
31149
31150
31151 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31152 PyObject *resultobj = 0;
31153 wxWindow *arg1 = (wxWindow *) 0 ;
31154 wxRect result;
31155 void *argp1 = 0 ;
31156 int res1 = 0 ;
31157 PyObject *swig_obj[1] ;
31158
31159 if (!args) SWIG_fail;
31160 swig_obj[0] = args;
31161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31162 if (!SWIG_IsOK(res1)) {
31163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31164 }
31165 arg1 = reinterpret_cast< wxWindow * >(argp1);
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 result = ((wxWindow const *)arg1)->GetScreenRect();
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31180 PyObject *resultobj = 0;
31181 wxWindow *arg1 = (wxWindow *) 0 ;
31182 wxSize result;
31183 void *argp1 = 0 ;
31184 int res1 = 0 ;
31185 PyObject *swig_obj[1] ;
31186
31187 if (!args) SWIG_fail;
31188 swig_obj[0] = args;
31189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31190 if (!SWIG_IsOK(res1)) {
31191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31192 }
31193 arg1 = reinterpret_cast< wxWindow * >(argp1);
31194 {
31195 PyThreadState* __tstate = wxPyBeginAllowThreads();
31196 result = ((wxWindow const *)arg1)->GetSize();
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 PyObject *resultobj = 0;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 int *arg2 = (int *) 0 ;
31211 int *arg3 = (int *) 0 ;
31212 void *argp1 = 0 ;
31213 int res1 = 0 ;
31214 int temp2 ;
31215 int res2 = SWIG_TMPOBJ ;
31216 int temp3 ;
31217 int res3 = SWIG_TMPOBJ ;
31218 PyObject *swig_obj[1] ;
31219
31220 arg2 = &temp2;
31221 arg3 = &temp3;
31222 if (!args) SWIG_fail;
31223 swig_obj[0] = args;
31224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31225 if (!SWIG_IsOK(res1)) {
31226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31227 }
31228 arg1 = reinterpret_cast< wxWindow * >(argp1);
31229 {
31230 PyThreadState* __tstate = wxPyBeginAllowThreads();
31231 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31232 wxPyEndAllowThreads(__tstate);
31233 if (PyErr_Occurred()) SWIG_fail;
31234 }
31235 resultobj = SWIG_Py_Void();
31236 if (SWIG_IsTmpObj(res2)) {
31237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31238 } else {
31239 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31240 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31241 }
31242 if (SWIG_IsTmpObj(res3)) {
31243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31244 } else {
31245 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31247 }
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31255 PyObject *resultobj = 0;
31256 wxWindow *arg1 = (wxWindow *) 0 ;
31257 wxRect result;
31258 void *argp1 = 0 ;
31259 int res1 = 0 ;
31260 PyObject *swig_obj[1] ;
31261
31262 if (!args) SWIG_fail;
31263 swig_obj[0] = args;
31264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31265 if (!SWIG_IsOK(res1)) {
31266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31267 }
31268 arg1 = reinterpret_cast< wxWindow * >(argp1);
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 result = ((wxWindow const *)arg1)->GetRect();
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31283 PyObject *resultobj = 0;
31284 wxWindow *arg1 = (wxWindow *) 0 ;
31285 wxSize result;
31286 void *argp1 = 0 ;
31287 int res1 = 0 ;
31288 PyObject *swig_obj[1] ;
31289
31290 if (!args) SWIG_fail;
31291 swig_obj[0] = args;
31292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31293 if (!SWIG_IsOK(res1)) {
31294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31295 }
31296 arg1 = reinterpret_cast< wxWindow * >(argp1);
31297 {
31298 PyThreadState* __tstate = wxPyBeginAllowThreads();
31299 result = ((wxWindow const *)arg1)->GetClientSize();
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31304 return resultobj;
31305 fail:
31306 return NULL;
31307 }
31308
31309
31310 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31311 PyObject *resultobj = 0;
31312 wxWindow *arg1 = (wxWindow *) 0 ;
31313 int *arg2 = (int *) 0 ;
31314 int *arg3 = (int *) 0 ;
31315 void *argp1 = 0 ;
31316 int res1 = 0 ;
31317 int temp2 ;
31318 int res2 = SWIG_TMPOBJ ;
31319 int temp3 ;
31320 int res3 = SWIG_TMPOBJ ;
31321 PyObject *swig_obj[1] ;
31322
31323 arg2 = &temp2;
31324 arg3 = &temp3;
31325 if (!args) SWIG_fail;
31326 swig_obj[0] = args;
31327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31328 if (!SWIG_IsOK(res1)) {
31329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31330 }
31331 arg1 = reinterpret_cast< wxWindow * >(argp1);
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31335 wxPyEndAllowThreads(__tstate);
31336 if (PyErr_Occurred()) SWIG_fail;
31337 }
31338 resultobj = SWIG_Py_Void();
31339 if (SWIG_IsTmpObj(res2)) {
31340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31341 } else {
31342 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31344 }
31345 if (SWIG_IsTmpObj(res3)) {
31346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31347 } else {
31348 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31350 }
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31358 PyObject *resultobj = 0;
31359 wxWindow *arg1 = (wxWindow *) 0 ;
31360 wxPoint result;
31361 void *argp1 = 0 ;
31362 int res1 = 0 ;
31363 PyObject *swig_obj[1] ;
31364
31365 if (!args) SWIG_fail;
31366 swig_obj[0] = args;
31367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31368 if (!SWIG_IsOK(res1)) {
31369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31370 }
31371 arg1 = reinterpret_cast< wxWindow * >(argp1);
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31379 return resultobj;
31380 fail:
31381 return NULL;
31382 }
31383
31384
31385 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31386 PyObject *resultobj = 0;
31387 wxWindow *arg1 = (wxWindow *) 0 ;
31388 wxRect result;
31389 void *argp1 = 0 ;
31390 int res1 = 0 ;
31391 PyObject *swig_obj[1] ;
31392
31393 if (!args) SWIG_fail;
31394 swig_obj[0] = args;
31395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31396 if (!SWIG_IsOK(res1)) {
31397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31398 }
31399 arg1 = reinterpret_cast< wxWindow * >(argp1);
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxWindow const *)arg1)->GetClientRect();
31403 wxPyEndAllowThreads(__tstate);
31404 if (PyErr_Occurred()) SWIG_fail;
31405 }
31406 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31407 return resultobj;
31408 fail:
31409 return NULL;
31410 }
31411
31412
31413 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31414 PyObject *resultobj = 0;
31415 wxWindow *arg1 = (wxWindow *) 0 ;
31416 wxSize result;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 PyObject *swig_obj[1] ;
31420
31421 if (!args) SWIG_fail;
31422 swig_obj[0] = args;
31423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31424 if (!SWIG_IsOK(res1)) {
31425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31426 }
31427 arg1 = reinterpret_cast< wxWindow * >(argp1);
31428 {
31429 PyThreadState* __tstate = wxPyBeginAllowThreads();
31430 result = ((wxWindow const *)arg1)->GetBestSize();
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 PyObject *resultobj = 0;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 int *arg2 = (int *) 0 ;
31445 int *arg3 = (int *) 0 ;
31446 void *argp1 = 0 ;
31447 int res1 = 0 ;
31448 int temp2 ;
31449 int res2 = SWIG_TMPOBJ ;
31450 int temp3 ;
31451 int res3 = SWIG_TMPOBJ ;
31452 PyObject *swig_obj[1] ;
31453
31454 arg2 = &temp2;
31455 arg3 = &temp3;
31456 if (!args) SWIG_fail;
31457 swig_obj[0] = args;
31458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31459 if (!SWIG_IsOK(res1)) {
31460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31461 }
31462 arg1 = reinterpret_cast< wxWindow * >(argp1);
31463 {
31464 PyThreadState* __tstate = wxPyBeginAllowThreads();
31465 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31466 wxPyEndAllowThreads(__tstate);
31467 if (PyErr_Occurred()) SWIG_fail;
31468 }
31469 resultobj = SWIG_Py_Void();
31470 if (SWIG_IsTmpObj(res2)) {
31471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31472 } else {
31473 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31475 }
31476 if (SWIG_IsTmpObj(res3)) {
31477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31478 } else {
31479 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31481 }
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31489 PyObject *resultobj = 0;
31490 wxWindow *arg1 = (wxWindow *) 0 ;
31491 void *argp1 = 0 ;
31492 int res1 = 0 ;
31493 PyObject *swig_obj[1] ;
31494
31495 if (!args) SWIG_fail;
31496 swig_obj[0] = args;
31497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31498 if (!SWIG_IsOK(res1)) {
31499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31500 }
31501 arg1 = reinterpret_cast< wxWindow * >(argp1);
31502 {
31503 PyThreadState* __tstate = wxPyBeginAllowThreads();
31504 (arg1)->InvalidateBestSize();
31505 wxPyEndAllowThreads(__tstate);
31506 if (PyErr_Occurred()) SWIG_fail;
31507 }
31508 resultobj = SWIG_Py_Void();
31509 return resultobj;
31510 fail:
31511 return NULL;
31512 }
31513
31514
31515 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31516 PyObject *resultobj = 0;
31517 wxWindow *arg1 = (wxWindow *) 0 ;
31518 wxSize *arg2 = 0 ;
31519 void *argp1 = 0 ;
31520 int res1 = 0 ;
31521 wxSize temp2 ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 char * kwnames[] = {
31525 (char *) "self",(char *) "size", NULL
31526 };
31527
31528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31530 if (!SWIG_IsOK(res1)) {
31531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31532 }
31533 arg1 = reinterpret_cast< wxWindow * >(argp1);
31534 {
31535 arg2 = &temp2;
31536 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31537 }
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31541 wxPyEndAllowThreads(__tstate);
31542 if (PyErr_Occurred()) SWIG_fail;
31543 }
31544 resultobj = SWIG_Py_Void();
31545 return resultobj;
31546 fail:
31547 return NULL;
31548 }
31549
31550
31551 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31552 PyObject *resultobj = 0;
31553 wxWindow *arg1 = (wxWindow *) 0 ;
31554 wxSize result;
31555 void *argp1 = 0 ;
31556 int res1 = 0 ;
31557 PyObject *swig_obj[1] ;
31558
31559 if (!args) SWIG_fail;
31560 swig_obj[0] = args;
31561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31564 }
31565 arg1 = reinterpret_cast< wxWindow * >(argp1);
31566 {
31567 PyThreadState* __tstate = wxPyBeginAllowThreads();
31568 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31569 wxPyEndAllowThreads(__tstate);
31570 if (PyErr_Occurred()) SWIG_fail;
31571 }
31572 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31580 PyObject *resultobj = 0;
31581 wxWindow *arg1 = (wxWindow *) 0 ;
31582 wxSize result;
31583 void *argp1 = 0 ;
31584 int res1 = 0 ;
31585 PyObject *swig_obj[1] ;
31586
31587 if (!args) SWIG_fail;
31588 swig_obj[0] = args;
31589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31590 if (!SWIG_IsOK(res1)) {
31591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31592 }
31593 arg1 = reinterpret_cast< wxWindow * >(argp1);
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31608 PyObject *resultobj = 0;
31609 wxWindow *arg1 = (wxWindow *) 0 ;
31610 int arg2 = (int) wxBOTH ;
31611 void *argp1 = 0 ;
31612 int res1 = 0 ;
31613 int val2 ;
31614 int ecode2 = 0 ;
31615 PyObject * obj0 = 0 ;
31616 PyObject * obj1 = 0 ;
31617 char * kwnames[] = {
31618 (char *) "self",(char *) "direction", NULL
31619 };
31620
31621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31623 if (!SWIG_IsOK(res1)) {
31624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31625 }
31626 arg1 = reinterpret_cast< wxWindow * >(argp1);
31627 if (obj1) {
31628 ecode2 = SWIG_AsVal_int(obj1, &val2);
31629 if (!SWIG_IsOK(ecode2)) {
31630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31631 }
31632 arg2 = static_cast< int >(val2);
31633 }
31634 {
31635 PyThreadState* __tstate = wxPyBeginAllowThreads();
31636 (arg1)->Center(arg2);
31637 wxPyEndAllowThreads(__tstate);
31638 if (PyErr_Occurred()) SWIG_fail;
31639 }
31640 resultobj = SWIG_Py_Void();
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj = 0;
31649 wxWindow *arg1 = (wxWindow *) 0 ;
31650 int arg2 = (int) wxBOTH ;
31651 void *argp1 = 0 ;
31652 int res1 = 0 ;
31653 int val2 ;
31654 int ecode2 = 0 ;
31655 PyObject * obj0 = 0 ;
31656 PyObject * obj1 = 0 ;
31657 char * kwnames[] = {
31658 (char *) "self",(char *) "dir", NULL
31659 };
31660
31661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31663 if (!SWIG_IsOK(res1)) {
31664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31665 }
31666 arg1 = reinterpret_cast< wxWindow * >(argp1);
31667 if (obj1) {
31668 ecode2 = SWIG_AsVal_int(obj1, &val2);
31669 if (!SWIG_IsOK(ecode2)) {
31670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31671 }
31672 arg2 = static_cast< int >(val2);
31673 }
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 (arg1)->CenterOnParent(arg2);
31677 wxPyEndAllowThreads(__tstate);
31678 if (PyErr_Occurred()) SWIG_fail;
31679 }
31680 resultobj = SWIG_Py_Void();
31681 return resultobj;
31682 fail:
31683 return NULL;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31688 PyObject *resultobj = 0;
31689 wxWindow *arg1 = (wxWindow *) 0 ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 PyObject *swig_obj[1] ;
31693
31694 if (!args) SWIG_fail;
31695 swig_obj[0] = args;
31696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31697 if (!SWIG_IsOK(res1)) {
31698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31699 }
31700 arg1 = reinterpret_cast< wxWindow * >(argp1);
31701 {
31702 PyThreadState* __tstate = wxPyBeginAllowThreads();
31703 (arg1)->Fit();
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 resultobj = SWIG_Py_Void();
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31715 PyObject *resultobj = 0;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 void *argp1 = 0 ;
31718 int res1 = 0 ;
31719 PyObject *swig_obj[1] ;
31720
31721 if (!args) SWIG_fail;
31722 swig_obj[0] = args;
31723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31724 if (!SWIG_IsOK(res1)) {
31725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31726 }
31727 arg1 = reinterpret_cast< wxWindow * >(argp1);
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->FitInside();
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_Py_Void();
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31742 PyObject *resultobj = 0;
31743 wxWindow *arg1 = (wxWindow *) 0 ;
31744 int arg2 ;
31745 int arg3 ;
31746 int arg4 = (int) -1 ;
31747 int arg5 = (int) -1 ;
31748 int arg6 = (int) -1 ;
31749 int arg7 = (int) -1 ;
31750 void *argp1 = 0 ;
31751 int res1 = 0 ;
31752 int val2 ;
31753 int ecode2 = 0 ;
31754 int val3 ;
31755 int ecode3 = 0 ;
31756 int val4 ;
31757 int ecode4 = 0 ;
31758 int val5 ;
31759 int ecode5 = 0 ;
31760 int val6 ;
31761 int ecode6 = 0 ;
31762 int val7 ;
31763 int ecode7 = 0 ;
31764 PyObject * obj0 = 0 ;
31765 PyObject * obj1 = 0 ;
31766 PyObject * obj2 = 0 ;
31767 PyObject * obj3 = 0 ;
31768 PyObject * obj4 = 0 ;
31769 PyObject * obj5 = 0 ;
31770 PyObject * obj6 = 0 ;
31771 char * kwnames[] = {
31772 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31773 };
31774
31775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31777 if (!SWIG_IsOK(res1)) {
31778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31779 }
31780 arg1 = reinterpret_cast< wxWindow * >(argp1);
31781 ecode2 = SWIG_AsVal_int(obj1, &val2);
31782 if (!SWIG_IsOK(ecode2)) {
31783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31784 }
31785 arg2 = static_cast< int >(val2);
31786 ecode3 = SWIG_AsVal_int(obj2, &val3);
31787 if (!SWIG_IsOK(ecode3)) {
31788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31789 }
31790 arg3 = static_cast< int >(val3);
31791 if (obj3) {
31792 ecode4 = SWIG_AsVal_int(obj3, &val4);
31793 if (!SWIG_IsOK(ecode4)) {
31794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31795 }
31796 arg4 = static_cast< int >(val4);
31797 }
31798 if (obj4) {
31799 ecode5 = SWIG_AsVal_int(obj4, &val5);
31800 if (!SWIG_IsOK(ecode5)) {
31801 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31802 }
31803 arg5 = static_cast< int >(val5);
31804 }
31805 if (obj5) {
31806 ecode6 = SWIG_AsVal_int(obj5, &val6);
31807 if (!SWIG_IsOK(ecode6)) {
31808 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31809 }
31810 arg6 = static_cast< int >(val6);
31811 }
31812 if (obj6) {
31813 ecode7 = SWIG_AsVal_int(obj6, &val7);
31814 if (!SWIG_IsOK(ecode7)) {
31815 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31816 }
31817 arg7 = static_cast< int >(val7);
31818 }
31819 {
31820 PyThreadState* __tstate = wxPyBeginAllowThreads();
31821 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31822 wxPyEndAllowThreads(__tstate);
31823 if (PyErr_Occurred()) SWIG_fail;
31824 }
31825 resultobj = SWIG_Py_Void();
31826 return resultobj;
31827 fail:
31828 return NULL;
31829 }
31830
31831
31832 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31833 PyObject *resultobj = 0;
31834 wxWindow *arg1 = (wxWindow *) 0 ;
31835 wxSize *arg2 = 0 ;
31836 wxSize const &arg3_defvalue = wxDefaultSize ;
31837 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31838 wxSize const &arg4_defvalue = wxDefaultSize ;
31839 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31840 void *argp1 = 0 ;
31841 int res1 = 0 ;
31842 wxSize temp2 ;
31843 wxSize temp3 ;
31844 wxSize temp4 ;
31845 PyObject * obj0 = 0 ;
31846 PyObject * obj1 = 0 ;
31847 PyObject * obj2 = 0 ;
31848 PyObject * obj3 = 0 ;
31849 char * kwnames[] = {
31850 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31851 };
31852
31853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31857 }
31858 arg1 = reinterpret_cast< wxWindow * >(argp1);
31859 {
31860 arg2 = &temp2;
31861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31862 }
31863 if (obj2) {
31864 {
31865 arg3 = &temp3;
31866 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31867 }
31868 }
31869 if (obj3) {
31870 {
31871 arg4 = &temp4;
31872 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31873 }
31874 }
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 resultobj = SWIG_Py_Void();
31882 return resultobj;
31883 fail:
31884 return NULL;
31885 }
31886
31887
31888 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31889 PyObject *resultobj = 0;
31890 wxWindow *arg1 = (wxWindow *) 0 ;
31891 int arg2 ;
31892 int arg3 ;
31893 int arg4 = (int) -1 ;
31894 int arg5 = (int) -1 ;
31895 void *argp1 = 0 ;
31896 int res1 = 0 ;
31897 int val2 ;
31898 int ecode2 = 0 ;
31899 int val3 ;
31900 int ecode3 = 0 ;
31901 int val4 ;
31902 int ecode4 = 0 ;
31903 int val5 ;
31904 int ecode5 = 0 ;
31905 PyObject * obj0 = 0 ;
31906 PyObject * obj1 = 0 ;
31907 PyObject * obj2 = 0 ;
31908 PyObject * obj3 = 0 ;
31909 PyObject * obj4 = 0 ;
31910 char * kwnames[] = {
31911 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31912 };
31913
31914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31916 if (!SWIG_IsOK(res1)) {
31917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31918 }
31919 arg1 = reinterpret_cast< wxWindow * >(argp1);
31920 ecode2 = SWIG_AsVal_int(obj1, &val2);
31921 if (!SWIG_IsOK(ecode2)) {
31922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31923 }
31924 arg2 = static_cast< int >(val2);
31925 ecode3 = SWIG_AsVal_int(obj2, &val3);
31926 if (!SWIG_IsOK(ecode3)) {
31927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31928 }
31929 arg3 = static_cast< int >(val3);
31930 if (obj3) {
31931 ecode4 = SWIG_AsVal_int(obj3, &val4);
31932 if (!SWIG_IsOK(ecode4)) {
31933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31934 }
31935 arg4 = static_cast< int >(val4);
31936 }
31937 if (obj4) {
31938 ecode5 = SWIG_AsVal_int(obj4, &val5);
31939 if (!SWIG_IsOK(ecode5)) {
31940 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31941 }
31942 arg5 = static_cast< int >(val5);
31943 }
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 resultobj = SWIG_Py_Void();
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj = 0;
31959 wxWindow *arg1 = (wxWindow *) 0 ;
31960 wxSize *arg2 = 0 ;
31961 wxSize const &arg3_defvalue = wxDefaultSize ;
31962 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31963 void *argp1 = 0 ;
31964 int res1 = 0 ;
31965 wxSize temp2 ;
31966 wxSize temp3 ;
31967 PyObject * obj0 = 0 ;
31968 PyObject * obj1 = 0 ;
31969 PyObject * obj2 = 0 ;
31970 char * kwnames[] = {
31971 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31972 };
31973
31974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31976 if (!SWIG_IsOK(res1)) {
31977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31978 }
31979 arg1 = reinterpret_cast< wxWindow * >(argp1);
31980 {
31981 arg2 = &temp2;
31982 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31983 }
31984 if (obj2) {
31985 {
31986 arg3 = &temp3;
31987 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31988 }
31989 }
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31993 wxPyEndAllowThreads(__tstate);
31994 if (PyErr_Occurred()) SWIG_fail;
31995 }
31996 resultobj = SWIG_Py_Void();
31997 return resultobj;
31998 fail:
31999 return NULL;
32000 }
32001
32002
32003 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32004 PyObject *resultobj = 0;
32005 wxWindow *arg1 = (wxWindow *) 0 ;
32006 wxSize result;
32007 void *argp1 = 0 ;
32008 int res1 = 0 ;
32009 PyObject *swig_obj[1] ;
32010
32011 if (!args) SWIG_fail;
32012 swig_obj[0] = args;
32013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32014 if (!SWIG_IsOK(res1)) {
32015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32016 }
32017 arg1 = reinterpret_cast< wxWindow * >(argp1);
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 result = ((wxWindow const *)arg1)->GetMaxSize();
32021 wxPyEndAllowThreads(__tstate);
32022 if (PyErr_Occurred()) SWIG_fail;
32023 }
32024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32025 return resultobj;
32026 fail:
32027 return NULL;
32028 }
32029
32030
32031 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32032 PyObject *resultobj = 0;
32033 wxWindow *arg1 = (wxWindow *) 0 ;
32034 wxSize result;
32035 void *argp1 = 0 ;
32036 int res1 = 0 ;
32037 PyObject *swig_obj[1] ;
32038
32039 if (!args) SWIG_fail;
32040 swig_obj[0] = args;
32041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32042 if (!SWIG_IsOK(res1)) {
32043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32044 }
32045 arg1 = reinterpret_cast< wxWindow * >(argp1);
32046 {
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = ((wxWindow const *)arg1)->GetMinSize();
32049 wxPyEndAllowThreads(__tstate);
32050 if (PyErr_Occurred()) SWIG_fail;
32051 }
32052 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32053 return resultobj;
32054 fail:
32055 return NULL;
32056 }
32057
32058
32059 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32060 PyObject *resultobj = 0;
32061 wxWindow *arg1 = (wxWindow *) 0 ;
32062 wxSize *arg2 = 0 ;
32063 void *argp1 = 0 ;
32064 int res1 = 0 ;
32065 wxSize temp2 ;
32066 PyObject * obj0 = 0 ;
32067 PyObject * obj1 = 0 ;
32068 char * kwnames[] = {
32069 (char *) "self",(char *) "minSize", NULL
32070 };
32071
32072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32074 if (!SWIG_IsOK(res1)) {
32075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32076 }
32077 arg1 = reinterpret_cast< wxWindow * >(argp1);
32078 {
32079 arg2 = &temp2;
32080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32081 }
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 (arg1)->SetMinSize((wxSize const &)*arg2);
32085 wxPyEndAllowThreads(__tstate);
32086 if (PyErr_Occurred()) SWIG_fail;
32087 }
32088 resultobj = SWIG_Py_Void();
32089 return resultobj;
32090 fail:
32091 return NULL;
32092 }
32093
32094
32095 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32096 PyObject *resultobj = 0;
32097 wxWindow *arg1 = (wxWindow *) 0 ;
32098 wxSize *arg2 = 0 ;
32099 void *argp1 = 0 ;
32100 int res1 = 0 ;
32101 wxSize temp2 ;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 char * kwnames[] = {
32105 (char *) "self",(char *) "maxSize", NULL
32106 };
32107
32108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32110 if (!SWIG_IsOK(res1)) {
32111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32112 }
32113 arg1 = reinterpret_cast< wxWindow * >(argp1);
32114 {
32115 arg2 = &temp2;
32116 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32117 }
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 (arg1)->SetMaxSize((wxSize const &)*arg2);
32121 wxPyEndAllowThreads(__tstate);
32122 if (PyErr_Occurred()) SWIG_fail;
32123 }
32124 resultobj = SWIG_Py_Void();
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 int result;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 PyObject *swig_obj[1] ;
32138
32139 if (!args) SWIG_fail;
32140 swig_obj[0] = args;
32141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32142 if (!SWIG_IsOK(res1)) {
32143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32144 }
32145 arg1 = reinterpret_cast< wxWindow * >(argp1);
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32149 wxPyEndAllowThreads(__tstate);
32150 if (PyErr_Occurred()) SWIG_fail;
32151 }
32152 resultobj = SWIG_From_int(static_cast< int >(result));
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 int result;
32163 void *argp1 = 0 ;
32164 int res1 = 0 ;
32165 PyObject *swig_obj[1] ;
32166
32167 if (!args) SWIG_fail;
32168 swig_obj[0] = args;
32169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 resultobj = SWIG_From_int(static_cast< int >(result));
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32188 PyObject *resultobj = 0;
32189 wxWindow *arg1 = (wxWindow *) 0 ;
32190 int result;
32191 void *argp1 = 0 ;
32192 int res1 = 0 ;
32193 PyObject *swig_obj[1] ;
32194
32195 if (!args) SWIG_fail;
32196 swig_obj[0] = args;
32197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32198 if (!SWIG_IsOK(res1)) {
32199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32200 }
32201 arg1 = reinterpret_cast< wxWindow * >(argp1);
32202 {
32203 PyThreadState* __tstate = wxPyBeginAllowThreads();
32204 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32205 wxPyEndAllowThreads(__tstate);
32206 if (PyErr_Occurred()) SWIG_fail;
32207 }
32208 resultobj = SWIG_From_int(static_cast< int >(result));
32209 return resultobj;
32210 fail:
32211 return NULL;
32212 }
32213
32214
32215 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32216 PyObject *resultobj = 0;
32217 wxWindow *arg1 = (wxWindow *) 0 ;
32218 int result;
32219 void *argp1 = 0 ;
32220 int res1 = 0 ;
32221 PyObject *swig_obj[1] ;
32222
32223 if (!args) SWIG_fail;
32224 swig_obj[0] = args;
32225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32228 }
32229 arg1 = reinterpret_cast< wxWindow * >(argp1);
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32233 wxPyEndAllowThreads(__tstate);
32234 if (PyErr_Occurred()) SWIG_fail;
32235 }
32236 resultobj = SWIG_From_int(static_cast< int >(result));
32237 return resultobj;
32238 fail:
32239 return NULL;
32240 }
32241
32242
32243 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32244 PyObject *resultobj = 0;
32245 wxWindow *arg1 = (wxWindow *) 0 ;
32246 wxSize *arg2 = 0 ;
32247 void *argp1 = 0 ;
32248 int res1 = 0 ;
32249 wxSize temp2 ;
32250 PyObject * obj0 = 0 ;
32251 PyObject * obj1 = 0 ;
32252 char * kwnames[] = {
32253 (char *) "self",(char *) "size", NULL
32254 };
32255
32256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32258 if (!SWIG_IsOK(res1)) {
32259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32260 }
32261 arg1 = reinterpret_cast< wxWindow * >(argp1);
32262 {
32263 arg2 = &temp2;
32264 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32265 }
32266 {
32267 PyThreadState* __tstate = wxPyBeginAllowThreads();
32268 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 resultobj = SWIG_Py_Void();
32273 return resultobj;
32274 fail:
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32280 PyObject *resultobj = 0;
32281 wxWindow *arg1 = (wxWindow *) 0 ;
32282 int arg2 ;
32283 int arg3 ;
32284 void *argp1 = 0 ;
32285 int res1 = 0 ;
32286 int val2 ;
32287 int ecode2 = 0 ;
32288 int val3 ;
32289 int ecode3 = 0 ;
32290 PyObject * obj0 = 0 ;
32291 PyObject * obj1 = 0 ;
32292 PyObject * obj2 = 0 ;
32293 char * kwnames[] = {
32294 (char *) "self",(char *) "w",(char *) "h", NULL
32295 };
32296
32297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32299 if (!SWIG_IsOK(res1)) {
32300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32301 }
32302 arg1 = reinterpret_cast< wxWindow * >(argp1);
32303 ecode2 = SWIG_AsVal_int(obj1, &val2);
32304 if (!SWIG_IsOK(ecode2)) {
32305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32306 }
32307 arg2 = static_cast< int >(val2);
32308 ecode3 = SWIG_AsVal_int(obj2, &val3);
32309 if (!SWIG_IsOK(ecode3)) {
32310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32311 }
32312 arg3 = static_cast< int >(val3);
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 (arg1)->SetVirtualSize(arg2,arg3);
32316 wxPyEndAllowThreads(__tstate);
32317 if (PyErr_Occurred()) SWIG_fail;
32318 }
32319 resultobj = SWIG_Py_Void();
32320 return resultobj;
32321 fail:
32322 return NULL;
32323 }
32324
32325
32326 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32327 PyObject *resultobj = 0;
32328 wxWindow *arg1 = (wxWindow *) 0 ;
32329 wxSize result;
32330 void *argp1 = 0 ;
32331 int res1 = 0 ;
32332 PyObject *swig_obj[1] ;
32333
32334 if (!args) SWIG_fail;
32335 swig_obj[0] = args;
32336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32337 if (!SWIG_IsOK(res1)) {
32338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32339 }
32340 arg1 = reinterpret_cast< wxWindow * >(argp1);
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = ((wxWindow const *)arg1)->GetVirtualSize();
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32348 return resultobj;
32349 fail:
32350 return NULL;
32351 }
32352
32353
32354 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32355 PyObject *resultobj = 0;
32356 wxWindow *arg1 = (wxWindow *) 0 ;
32357 int *arg2 = (int *) 0 ;
32358 int *arg3 = (int *) 0 ;
32359 void *argp1 = 0 ;
32360 int res1 = 0 ;
32361 int temp2 ;
32362 int res2 = SWIG_TMPOBJ ;
32363 int temp3 ;
32364 int res3 = SWIG_TMPOBJ ;
32365 PyObject *swig_obj[1] ;
32366
32367 arg2 = &temp2;
32368 arg3 = &temp3;
32369 if (!args) SWIG_fail;
32370 swig_obj[0] = args;
32371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 {
32377 PyThreadState* __tstate = wxPyBeginAllowThreads();
32378 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32379 wxPyEndAllowThreads(__tstate);
32380 if (PyErr_Occurred()) SWIG_fail;
32381 }
32382 resultobj = SWIG_Py_Void();
32383 if (SWIG_IsTmpObj(res2)) {
32384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32385 } else {
32386 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32388 }
32389 if (SWIG_IsTmpObj(res3)) {
32390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32391 } else {
32392 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32394 }
32395 return resultobj;
32396 fail:
32397 return NULL;
32398 }
32399
32400
32401 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32402 PyObject *resultobj = 0;
32403 wxWindow *arg1 = (wxWindow *) 0 ;
32404 wxSize result;
32405 void *argp1 = 0 ;
32406 int res1 = 0 ;
32407 PyObject *swig_obj[1] ;
32408
32409 if (!args) SWIG_fail;
32410 swig_obj[0] = args;
32411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32412 if (!SWIG_IsOK(res1)) {
32413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32414 }
32415 arg1 = reinterpret_cast< wxWindow * >(argp1);
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32430 PyObject *resultobj = 0;
32431 wxWindow *arg1 = (wxWindow *) 0 ;
32432 bool arg2 = (bool) true ;
32433 bool result;
32434 void *argp1 = 0 ;
32435 int res1 = 0 ;
32436 bool val2 ;
32437 int ecode2 = 0 ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char * kwnames[] = {
32441 (char *) "self",(char *) "show", NULL
32442 };
32443
32444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32446 if (!SWIG_IsOK(res1)) {
32447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32448 }
32449 arg1 = reinterpret_cast< wxWindow * >(argp1);
32450 if (obj1) {
32451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32452 if (!SWIG_IsOK(ecode2)) {
32453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32454 }
32455 arg2 = static_cast< bool >(val2);
32456 }
32457 {
32458 PyThreadState* __tstate = wxPyBeginAllowThreads();
32459 result = (bool)(arg1)->Show(arg2);
32460 wxPyEndAllowThreads(__tstate);
32461 if (PyErr_Occurred()) SWIG_fail;
32462 }
32463 {
32464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32465 }
32466 return resultobj;
32467 fail:
32468 return NULL;
32469 }
32470
32471
32472 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32473 PyObject *resultobj = 0;
32474 wxWindow *arg1 = (wxWindow *) 0 ;
32475 bool result;
32476 void *argp1 = 0 ;
32477 int res1 = 0 ;
32478 PyObject *swig_obj[1] ;
32479
32480 if (!args) SWIG_fail;
32481 swig_obj[0] = args;
32482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32483 if (!SWIG_IsOK(res1)) {
32484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32485 }
32486 arg1 = reinterpret_cast< wxWindow * >(argp1);
32487 {
32488 PyThreadState* __tstate = wxPyBeginAllowThreads();
32489 result = (bool)(arg1)->Hide();
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 {
32494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32495 }
32496 return resultobj;
32497 fail:
32498 return NULL;
32499 }
32500
32501
32502 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj = 0;
32504 wxWindow *arg1 = (wxWindow *) 0 ;
32505 bool arg2 = (bool) true ;
32506 bool result;
32507 void *argp1 = 0 ;
32508 int res1 = 0 ;
32509 bool val2 ;
32510 int ecode2 = 0 ;
32511 PyObject * obj0 = 0 ;
32512 PyObject * obj1 = 0 ;
32513 char * kwnames[] = {
32514 (char *) "self",(char *) "enable", NULL
32515 };
32516
32517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32519 if (!SWIG_IsOK(res1)) {
32520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32521 }
32522 arg1 = reinterpret_cast< wxWindow * >(argp1);
32523 if (obj1) {
32524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32525 if (!SWIG_IsOK(ecode2)) {
32526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32527 }
32528 arg2 = static_cast< bool >(val2);
32529 }
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (bool)(arg1)->Enable(arg2);
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 {
32537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32538 }
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxWindow *arg1 = (wxWindow *) 0 ;
32548 bool result;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32558 }
32559 arg1 = reinterpret_cast< wxWindow * >(argp1);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 result = (bool)(arg1)->Disable();
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 {
32567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32568 }
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32576 PyObject *resultobj = 0;
32577 wxWindow *arg1 = (wxWindow *) 0 ;
32578 bool result;
32579 void *argp1 = 0 ;
32580 int res1 = 0 ;
32581 PyObject *swig_obj[1] ;
32582
32583 if (!args) SWIG_fail;
32584 swig_obj[0] = args;
32585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32586 if (!SWIG_IsOK(res1)) {
32587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32588 }
32589 arg1 = reinterpret_cast< wxWindow * >(argp1);
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 result = (bool)((wxWindow const *)arg1)->IsShown();
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 {
32597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32598 }
32599 return resultobj;
32600 fail:
32601 return NULL;
32602 }
32603
32604
32605 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32606 PyObject *resultobj = 0;
32607 wxWindow *arg1 = (wxWindow *) 0 ;
32608 bool result;
32609 void *argp1 = 0 ;
32610 int res1 = 0 ;
32611 PyObject *swig_obj[1] ;
32612
32613 if (!args) SWIG_fail;
32614 swig_obj[0] = args;
32615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32618 }
32619 arg1 = reinterpret_cast< wxWindow * >(argp1);
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 {
32627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32628 }
32629 return resultobj;
32630 fail:
32631 return NULL;
32632 }
32633
32634
32635 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32636 PyObject *resultobj = 0;
32637 wxWindow *arg1 = (wxWindow *) 0 ;
32638 long arg2 ;
32639 void *argp1 = 0 ;
32640 int res1 = 0 ;
32641 long val2 ;
32642 int ecode2 = 0 ;
32643 PyObject * obj0 = 0 ;
32644 PyObject * obj1 = 0 ;
32645 char * kwnames[] = {
32646 (char *) "self",(char *) "style", NULL
32647 };
32648
32649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32651 if (!SWIG_IsOK(res1)) {
32652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32653 }
32654 arg1 = reinterpret_cast< wxWindow * >(argp1);
32655 ecode2 = SWIG_AsVal_long(obj1, &val2);
32656 if (!SWIG_IsOK(ecode2)) {
32657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32658 }
32659 arg2 = static_cast< long >(val2);
32660 {
32661 PyThreadState* __tstate = wxPyBeginAllowThreads();
32662 (arg1)->SetWindowStyleFlag(arg2);
32663 wxPyEndAllowThreads(__tstate);
32664 if (PyErr_Occurred()) SWIG_fail;
32665 }
32666 resultobj = SWIG_Py_Void();
32667 return resultobj;
32668 fail:
32669 return NULL;
32670 }
32671
32672
32673 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32674 PyObject *resultobj = 0;
32675 wxWindow *arg1 = (wxWindow *) 0 ;
32676 long result;
32677 void *argp1 = 0 ;
32678 int res1 = 0 ;
32679 PyObject *swig_obj[1] ;
32680
32681 if (!args) SWIG_fail;
32682 swig_obj[0] = args;
32683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32684 if (!SWIG_IsOK(res1)) {
32685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32686 }
32687 arg1 = reinterpret_cast< wxWindow * >(argp1);
32688 {
32689 PyThreadState* __tstate = wxPyBeginAllowThreads();
32690 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32691 wxPyEndAllowThreads(__tstate);
32692 if (PyErr_Occurred()) SWIG_fail;
32693 }
32694 resultobj = SWIG_From_long(static_cast< long >(result));
32695 return resultobj;
32696 fail:
32697 return NULL;
32698 }
32699
32700
32701 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32702 PyObject *resultobj = 0;
32703 wxWindow *arg1 = (wxWindow *) 0 ;
32704 int arg2 ;
32705 bool result;
32706 void *argp1 = 0 ;
32707 int res1 = 0 ;
32708 int val2 ;
32709 int ecode2 = 0 ;
32710 PyObject * obj0 = 0 ;
32711 PyObject * obj1 = 0 ;
32712 char * kwnames[] = {
32713 (char *) "self",(char *) "flag", NULL
32714 };
32715
32716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32718 if (!SWIG_IsOK(res1)) {
32719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32720 }
32721 arg1 = reinterpret_cast< wxWindow * >(argp1);
32722 ecode2 = SWIG_AsVal_int(obj1, &val2);
32723 if (!SWIG_IsOK(ecode2)) {
32724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32725 }
32726 arg2 = static_cast< int >(val2);
32727 {
32728 PyThreadState* __tstate = wxPyBeginAllowThreads();
32729 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32730 wxPyEndAllowThreads(__tstate);
32731 if (PyErr_Occurred()) SWIG_fail;
32732 }
32733 {
32734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32735 }
32736 return resultobj;
32737 fail:
32738 return NULL;
32739 }
32740
32741
32742 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 PyObject *resultobj = 0;
32744 wxWindow *arg1 = (wxWindow *) 0 ;
32745 bool result;
32746 void *argp1 = 0 ;
32747 int res1 = 0 ;
32748 PyObject *swig_obj[1] ;
32749
32750 if (!args) SWIG_fail;
32751 swig_obj[0] = args;
32752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32753 if (!SWIG_IsOK(res1)) {
32754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32755 }
32756 arg1 = reinterpret_cast< wxWindow * >(argp1);
32757 {
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (bool)((wxWindow const *)arg1)->IsRetained();
32760 wxPyEndAllowThreads(__tstate);
32761 if (PyErr_Occurred()) SWIG_fail;
32762 }
32763 {
32764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32765 }
32766 return resultobj;
32767 fail:
32768 return NULL;
32769 }
32770
32771
32772 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32773 PyObject *resultobj = 0;
32774 wxWindow *arg1 = (wxWindow *) 0 ;
32775 long arg2 ;
32776 void *argp1 = 0 ;
32777 int res1 = 0 ;
32778 long val2 ;
32779 int ecode2 = 0 ;
32780 PyObject * obj0 = 0 ;
32781 PyObject * obj1 = 0 ;
32782 char * kwnames[] = {
32783 (char *) "self",(char *) "exStyle", NULL
32784 };
32785
32786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32788 if (!SWIG_IsOK(res1)) {
32789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32790 }
32791 arg1 = reinterpret_cast< wxWindow * >(argp1);
32792 ecode2 = SWIG_AsVal_long(obj1, &val2);
32793 if (!SWIG_IsOK(ecode2)) {
32794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32795 }
32796 arg2 = static_cast< long >(val2);
32797 {
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 (arg1)->SetExtraStyle(arg2);
32800 wxPyEndAllowThreads(__tstate);
32801 if (PyErr_Occurred()) SWIG_fail;
32802 }
32803 resultobj = SWIG_Py_Void();
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 PyObject *resultobj = 0;
32812 wxWindow *arg1 = (wxWindow *) 0 ;
32813 long result;
32814 void *argp1 = 0 ;
32815 int res1 = 0 ;
32816 PyObject *swig_obj[1] ;
32817
32818 if (!args) SWIG_fail;
32819 swig_obj[0] = args;
32820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32823 }
32824 arg1 = reinterpret_cast< wxWindow * >(argp1);
32825 {
32826 PyThreadState* __tstate = wxPyBeginAllowThreads();
32827 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32828 wxPyEndAllowThreads(__tstate);
32829 if (PyErr_Occurred()) SWIG_fail;
32830 }
32831 resultobj = SWIG_From_long(static_cast< long >(result));
32832 return resultobj;
32833 fail:
32834 return NULL;
32835 }
32836
32837
32838 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32839 PyObject *resultobj = 0;
32840 wxWindow *arg1 = (wxWindow *) 0 ;
32841 bool arg2 = (bool) true ;
32842 void *argp1 = 0 ;
32843 int res1 = 0 ;
32844 bool val2 ;
32845 int ecode2 = 0 ;
32846 PyObject * obj0 = 0 ;
32847 PyObject * obj1 = 0 ;
32848 char * kwnames[] = {
32849 (char *) "self",(char *) "modal", NULL
32850 };
32851
32852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32854 if (!SWIG_IsOK(res1)) {
32855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32856 }
32857 arg1 = reinterpret_cast< wxWindow * >(argp1);
32858 if (obj1) {
32859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32860 if (!SWIG_IsOK(ecode2)) {
32861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32862 }
32863 arg2 = static_cast< bool >(val2);
32864 }
32865 {
32866 PyThreadState* __tstate = wxPyBeginAllowThreads();
32867 (arg1)->MakeModal(arg2);
32868 wxPyEndAllowThreads(__tstate);
32869 if (PyErr_Occurred()) SWIG_fail;
32870 }
32871 resultobj = SWIG_Py_Void();
32872 return resultobj;
32873 fail:
32874 return NULL;
32875 }
32876
32877
32878 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32879 PyObject *resultobj = 0;
32880 wxWindow *arg1 = (wxWindow *) 0 ;
32881 bool arg2 ;
32882 void *argp1 = 0 ;
32883 int res1 = 0 ;
32884 bool val2 ;
32885 int ecode2 = 0 ;
32886 PyObject * obj0 = 0 ;
32887 PyObject * obj1 = 0 ;
32888 char * kwnames[] = {
32889 (char *) "self",(char *) "enableTheme", NULL
32890 };
32891
32892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32894 if (!SWIG_IsOK(res1)) {
32895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32896 }
32897 arg1 = reinterpret_cast< wxWindow * >(argp1);
32898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32899 if (!SWIG_IsOK(ecode2)) {
32900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32901 }
32902 arg2 = static_cast< bool >(val2);
32903 {
32904 PyThreadState* __tstate = wxPyBeginAllowThreads();
32905 (arg1)->SetThemeEnabled(arg2);
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 resultobj = SWIG_Py_Void();
32910 return resultobj;
32911 fail:
32912 return NULL;
32913 }
32914
32915
32916 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32917 PyObject *resultobj = 0;
32918 wxWindow *arg1 = (wxWindow *) 0 ;
32919 bool result;
32920 void *argp1 = 0 ;
32921 int res1 = 0 ;
32922 PyObject *swig_obj[1] ;
32923
32924 if (!args) SWIG_fail;
32925 swig_obj[0] = args;
32926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32927 if (!SWIG_IsOK(res1)) {
32928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32929 }
32930 arg1 = reinterpret_cast< wxWindow * >(argp1);
32931 {
32932 PyThreadState* __tstate = wxPyBeginAllowThreads();
32933 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32934 wxPyEndAllowThreads(__tstate);
32935 if (PyErr_Occurred()) SWIG_fail;
32936 }
32937 {
32938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32939 }
32940 return resultobj;
32941 fail:
32942 return NULL;
32943 }
32944
32945
32946 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32947 PyObject *resultobj = 0;
32948 wxWindow *arg1 = (wxWindow *) 0 ;
32949 void *argp1 = 0 ;
32950 int res1 = 0 ;
32951 PyObject *swig_obj[1] ;
32952
32953 if (!args) SWIG_fail;
32954 swig_obj[0] = args;
32955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32956 if (!SWIG_IsOK(res1)) {
32957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32958 }
32959 arg1 = reinterpret_cast< wxWindow * >(argp1);
32960 {
32961 PyThreadState* __tstate = wxPyBeginAllowThreads();
32962 (arg1)->SetFocus();
32963 wxPyEndAllowThreads(__tstate);
32964 if (PyErr_Occurred()) SWIG_fail;
32965 }
32966 resultobj = SWIG_Py_Void();
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32974 PyObject *resultobj = 0;
32975 wxWindow *arg1 = (wxWindow *) 0 ;
32976 void *argp1 = 0 ;
32977 int res1 = 0 ;
32978 PyObject *swig_obj[1] ;
32979
32980 if (!args) SWIG_fail;
32981 swig_obj[0] = args;
32982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32983 if (!SWIG_IsOK(res1)) {
32984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32985 }
32986 arg1 = reinterpret_cast< wxWindow * >(argp1);
32987 {
32988 PyThreadState* __tstate = wxPyBeginAllowThreads();
32989 (arg1)->SetFocusFromKbd();
32990 wxPyEndAllowThreads(__tstate);
32991 if (PyErr_Occurred()) SWIG_fail;
32992 }
32993 resultobj = SWIG_Py_Void();
32994 return resultobj;
32995 fail:
32996 return NULL;
32997 }
32998
32999
33000 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33001 PyObject *resultobj = 0;
33002 wxWindow *result = 0 ;
33003
33004 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33005 {
33006 if (!wxPyCheckForApp()) SWIG_fail;
33007 PyThreadState* __tstate = wxPyBeginAllowThreads();
33008 result = (wxWindow *)wxWindow::FindFocus();
33009 wxPyEndAllowThreads(__tstate);
33010 if (PyErr_Occurred()) SWIG_fail;
33011 }
33012 {
33013 resultobj = wxPyMake_wxObject(result, 0);
33014 }
33015 return resultobj;
33016 fail:
33017 return NULL;
33018 }
33019
33020
33021 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33022 PyObject *resultobj = 0;
33023 wxWindow *arg1 = (wxWindow *) 0 ;
33024 bool result;
33025 void *argp1 = 0 ;
33026 int res1 = 0 ;
33027 PyObject *swig_obj[1] ;
33028
33029 if (!args) SWIG_fail;
33030 swig_obj[0] = args;
33031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33032 if (!SWIG_IsOK(res1)) {
33033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33034 }
33035 arg1 = reinterpret_cast< wxWindow * >(argp1);
33036 {
33037 PyThreadState* __tstate = wxPyBeginAllowThreads();
33038 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 {
33043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33044 }
33045 return resultobj;
33046 fail:
33047 return NULL;
33048 }
33049
33050
33051 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33052 PyObject *resultobj = 0;
33053 wxWindow *arg1 = (wxWindow *) 0 ;
33054 bool result;
33055 void *argp1 = 0 ;
33056 int res1 = 0 ;
33057 PyObject *swig_obj[1] ;
33058
33059 if (!args) SWIG_fail;
33060 swig_obj[0] = args;
33061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33062 if (!SWIG_IsOK(res1)) {
33063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33064 }
33065 arg1 = reinterpret_cast< wxWindow * >(argp1);
33066 {
33067 PyThreadState* __tstate = wxPyBeginAllowThreads();
33068 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 {
33073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33074 }
33075 return resultobj;
33076 fail:
33077 return NULL;
33078 }
33079
33080
33081 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33082 PyObject *resultobj = 0;
33083 wxWindow *arg1 = (wxWindow *) 0 ;
33084 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33085 bool result;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 int val2 ;
33089 int ecode2 = 0 ;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 char * kwnames[] = {
33093 (char *) "self",(char *) "flags", NULL
33094 };
33095
33096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33098 if (!SWIG_IsOK(res1)) {
33099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33100 }
33101 arg1 = reinterpret_cast< wxWindow * >(argp1);
33102 if (obj1) {
33103 ecode2 = SWIG_AsVal_int(obj1, &val2);
33104 if (!SWIG_IsOK(ecode2)) {
33105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33106 }
33107 arg2 = static_cast< int >(val2);
33108 }
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 result = (bool)(arg1)->Navigate(arg2);
33112 wxPyEndAllowThreads(__tstate);
33113 if (PyErr_Occurred()) SWIG_fail;
33114 }
33115 {
33116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33117 }
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33125 PyObject *resultobj = 0;
33126 wxWindow *arg1 = (wxWindow *) 0 ;
33127 wxWindow *arg2 = (wxWindow *) 0 ;
33128 void *argp1 = 0 ;
33129 int res1 = 0 ;
33130 void *argp2 = 0 ;
33131 int res2 = 0 ;
33132 PyObject * obj0 = 0 ;
33133 PyObject * obj1 = 0 ;
33134 char * kwnames[] = {
33135 (char *) "self",(char *) "win", NULL
33136 };
33137
33138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33142 }
33143 arg1 = reinterpret_cast< wxWindow * >(argp1);
33144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res2)) {
33146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33147 }
33148 arg2 = reinterpret_cast< wxWindow * >(argp2);
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 (arg1)->MoveAfterInTabOrder(arg2);
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 resultobj = SWIG_Py_Void();
33156 return resultobj;
33157 fail:
33158 return NULL;
33159 }
33160
33161
33162 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33163 PyObject *resultobj = 0;
33164 wxWindow *arg1 = (wxWindow *) 0 ;
33165 wxWindow *arg2 = (wxWindow *) 0 ;
33166 void *argp1 = 0 ;
33167 int res1 = 0 ;
33168 void *argp2 = 0 ;
33169 int res2 = 0 ;
33170 PyObject * obj0 = 0 ;
33171 PyObject * obj1 = 0 ;
33172 char * kwnames[] = {
33173 (char *) "self",(char *) "win", NULL
33174 };
33175
33176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33178 if (!SWIG_IsOK(res1)) {
33179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33180 }
33181 arg1 = reinterpret_cast< wxWindow * >(argp1);
33182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33183 if (!SWIG_IsOK(res2)) {
33184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33185 }
33186 arg2 = reinterpret_cast< wxWindow * >(argp2);
33187 {
33188 PyThreadState* __tstate = wxPyBeginAllowThreads();
33189 (arg1)->MoveBeforeInTabOrder(arg2);
33190 wxPyEndAllowThreads(__tstate);
33191 if (PyErr_Occurred()) SWIG_fail;
33192 }
33193 resultobj = SWIG_Py_Void();
33194 return resultobj;
33195 fail:
33196 return NULL;
33197 }
33198
33199
33200 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33201 PyObject *resultobj = 0;
33202 wxWindow *arg1 = (wxWindow *) 0 ;
33203 PyObject *result = 0 ;
33204 void *argp1 = 0 ;
33205 int res1 = 0 ;
33206 PyObject *swig_obj[1] ;
33207
33208 if (!args) SWIG_fail;
33209 swig_obj[0] = args;
33210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33213 }
33214 arg1 = reinterpret_cast< wxWindow * >(argp1);
33215 {
33216 PyThreadState* __tstate = wxPyBeginAllowThreads();
33217 result = (PyObject *)wxWindow_GetChildren(arg1);
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 resultobj = result;
33222 return resultobj;
33223 fail:
33224 return NULL;
33225 }
33226
33227
33228 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33229 PyObject *resultobj = 0;
33230 wxWindow *arg1 = (wxWindow *) 0 ;
33231 wxWindow *result = 0 ;
33232 void *argp1 = 0 ;
33233 int res1 = 0 ;
33234 PyObject *swig_obj[1] ;
33235
33236 if (!args) SWIG_fail;
33237 swig_obj[0] = args;
33238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33239 if (!SWIG_IsOK(res1)) {
33240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33241 }
33242 arg1 = reinterpret_cast< wxWindow * >(argp1);
33243 {
33244 PyThreadState* __tstate = wxPyBeginAllowThreads();
33245 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 {
33250 resultobj = wxPyMake_wxObject(result, 0);
33251 }
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33259 PyObject *resultobj = 0;
33260 wxWindow *arg1 = (wxWindow *) 0 ;
33261 wxWindow *result = 0 ;
33262 void *argp1 = 0 ;
33263 int res1 = 0 ;
33264 PyObject *swig_obj[1] ;
33265
33266 if (!args) SWIG_fail;
33267 swig_obj[0] = args;
33268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33271 }
33272 arg1 = reinterpret_cast< wxWindow * >(argp1);
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33276 wxPyEndAllowThreads(__tstate);
33277 if (PyErr_Occurred()) SWIG_fail;
33278 }
33279 {
33280 resultobj = wxPyMake_wxObject(result, 0);
33281 }
33282 return resultobj;
33283 fail:
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33289 PyObject *resultobj = 0;
33290 wxWindow *arg1 = (wxWindow *) 0 ;
33291 bool result;
33292 void *argp1 = 0 ;
33293 int res1 = 0 ;
33294 PyObject *swig_obj[1] ;
33295
33296 if (!args) SWIG_fail;
33297 swig_obj[0] = args;
33298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33301 }
33302 arg1 = reinterpret_cast< wxWindow * >(argp1);
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 {
33310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33311 }
33312 return resultobj;
33313 fail:
33314 return NULL;
33315 }
33316
33317
33318 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33319 PyObject *resultobj = 0;
33320 wxWindow *arg1 = (wxWindow *) 0 ;
33321 wxWindow *arg2 = (wxWindow *) 0 ;
33322 bool result;
33323 void *argp1 = 0 ;
33324 int res1 = 0 ;
33325 void *argp2 = 0 ;
33326 int res2 = 0 ;
33327 PyObject * obj0 = 0 ;
33328 PyObject * obj1 = 0 ;
33329 char * kwnames[] = {
33330 (char *) "self",(char *) "newParent", NULL
33331 };
33332
33333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33335 if (!SWIG_IsOK(res1)) {
33336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33337 }
33338 arg1 = reinterpret_cast< wxWindow * >(argp1);
33339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33340 if (!SWIG_IsOK(res2)) {
33341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33342 }
33343 arg2 = reinterpret_cast< wxWindow * >(argp2);
33344 {
33345 PyThreadState* __tstate = wxPyBeginAllowThreads();
33346 result = (bool)(arg1)->Reparent(arg2);
33347 wxPyEndAllowThreads(__tstate);
33348 if (PyErr_Occurred()) SWIG_fail;
33349 }
33350 {
33351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33352 }
33353 return resultobj;
33354 fail:
33355 return NULL;
33356 }
33357
33358
33359 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33360 PyObject *resultobj = 0;
33361 wxWindow *arg1 = (wxWindow *) 0 ;
33362 wxWindow *arg2 = (wxWindow *) 0 ;
33363 void *argp1 = 0 ;
33364 int res1 = 0 ;
33365 void *argp2 = 0 ;
33366 int res2 = 0 ;
33367 PyObject * obj0 = 0 ;
33368 PyObject * obj1 = 0 ;
33369 char * kwnames[] = {
33370 (char *) "self",(char *) "child", NULL
33371 };
33372
33373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33375 if (!SWIG_IsOK(res1)) {
33376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33377 }
33378 arg1 = reinterpret_cast< wxWindow * >(argp1);
33379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33380 if (!SWIG_IsOK(res2)) {
33381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33382 }
33383 arg2 = reinterpret_cast< wxWindow * >(argp2);
33384 {
33385 PyThreadState* __tstate = wxPyBeginAllowThreads();
33386 (arg1)->AddChild(arg2);
33387 wxPyEndAllowThreads(__tstate);
33388 if (PyErr_Occurred()) SWIG_fail;
33389 }
33390 resultobj = SWIG_Py_Void();
33391 return resultobj;
33392 fail:
33393 return NULL;
33394 }
33395
33396
33397 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33398 PyObject *resultobj = 0;
33399 wxWindow *arg1 = (wxWindow *) 0 ;
33400 wxWindow *arg2 = (wxWindow *) 0 ;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 void *argp2 = 0 ;
33404 int res2 = 0 ;
33405 PyObject * obj0 = 0 ;
33406 PyObject * obj1 = 0 ;
33407 char * kwnames[] = {
33408 (char *) "self",(char *) "child", NULL
33409 };
33410
33411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33413 if (!SWIG_IsOK(res1)) {
33414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33415 }
33416 arg1 = reinterpret_cast< wxWindow * >(argp1);
33417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33418 if (!SWIG_IsOK(res2)) {
33419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33420 }
33421 arg2 = reinterpret_cast< wxWindow * >(argp2);
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 (arg1)->RemoveChild(arg2);
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 resultobj = SWIG_Py_Void();
33429 return resultobj;
33430 fail:
33431 return NULL;
33432 }
33433
33434
33435 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33436 PyObject *resultobj = 0;
33437 wxWindow *arg1 = (wxWindow *) 0 ;
33438 bool arg2 ;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 bool val2 ;
33442 int ecode2 = 0 ;
33443 PyObject * obj0 = 0 ;
33444 PyObject * obj1 = 0 ;
33445 char * kwnames[] = {
33446 (char *) "self",(char *) "on", NULL
33447 };
33448
33449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33456 if (!SWIG_IsOK(ecode2)) {
33457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33458 }
33459 arg2 = static_cast< bool >(val2);
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 wxWindow_SetDoubleBuffered(arg1,arg2);
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_Py_Void();
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33474 PyObject *resultobj = 0;
33475 wxWindow *arg1 = (wxWindow *) 0 ;
33476 long arg2 ;
33477 wxWindow *result = 0 ;
33478 void *argp1 = 0 ;
33479 int res1 = 0 ;
33480 long val2 ;
33481 int ecode2 = 0 ;
33482 PyObject * obj0 = 0 ;
33483 PyObject * obj1 = 0 ;
33484 char * kwnames[] = {
33485 (char *) "self",(char *) "winid", NULL
33486 };
33487
33488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 ecode2 = SWIG_AsVal_long(obj1, &val2);
33495 if (!SWIG_IsOK(ecode2)) {
33496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33497 }
33498 arg2 = static_cast< long >(val2);
33499 {
33500 PyThreadState* __tstate = wxPyBeginAllowThreads();
33501 result = (wxWindow *)(arg1)->FindWindow(arg2);
33502 wxPyEndAllowThreads(__tstate);
33503 if (PyErr_Occurred()) SWIG_fail;
33504 }
33505 {
33506 resultobj = wxPyMake_wxObject(result, 0);
33507 }
33508 return resultobj;
33509 fail:
33510 return NULL;
33511 }
33512
33513
33514 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33515 PyObject *resultobj = 0;
33516 wxWindow *arg1 = (wxWindow *) 0 ;
33517 wxString *arg2 = 0 ;
33518 wxWindow *result = 0 ;
33519 void *argp1 = 0 ;
33520 int res1 = 0 ;
33521 bool temp2 = false ;
33522 PyObject * obj0 = 0 ;
33523 PyObject * obj1 = 0 ;
33524 char * kwnames[] = {
33525 (char *) "self",(char *) "name", NULL
33526 };
33527
33528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33530 if (!SWIG_IsOK(res1)) {
33531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33532 }
33533 arg1 = reinterpret_cast< wxWindow * >(argp1);
33534 {
33535 arg2 = wxString_in_helper(obj1);
33536 if (arg2 == NULL) SWIG_fail;
33537 temp2 = true;
33538 }
33539 {
33540 PyThreadState* __tstate = wxPyBeginAllowThreads();
33541 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33542 wxPyEndAllowThreads(__tstate);
33543 if (PyErr_Occurred()) SWIG_fail;
33544 }
33545 {
33546 resultobj = wxPyMake_wxObject(result, 0);
33547 }
33548 {
33549 if (temp2)
33550 delete arg2;
33551 }
33552 return resultobj;
33553 fail:
33554 {
33555 if (temp2)
33556 delete arg2;
33557 }
33558 return NULL;
33559 }
33560
33561
33562 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33563 PyObject *resultobj = 0;
33564 wxWindow *arg1 = (wxWindow *) 0 ;
33565 wxEvtHandler *result = 0 ;
33566 void *argp1 = 0 ;
33567 int res1 = 0 ;
33568 PyObject *swig_obj[1] ;
33569
33570 if (!args) SWIG_fail;
33571 swig_obj[0] = args;
33572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33573 if (!SWIG_IsOK(res1)) {
33574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33575 }
33576 arg1 = reinterpret_cast< wxWindow * >(argp1);
33577 {
33578 PyThreadState* __tstate = wxPyBeginAllowThreads();
33579 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33580 wxPyEndAllowThreads(__tstate);
33581 if (PyErr_Occurred()) SWIG_fail;
33582 }
33583 {
33584 resultobj = wxPyMake_wxObject(result, 0);
33585 }
33586 return resultobj;
33587 fail:
33588 return NULL;
33589 }
33590
33591
33592 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj = 0;
33594 wxWindow *arg1 = (wxWindow *) 0 ;
33595 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 void *argp2 = 0 ;
33599 int res2 = 0 ;
33600 PyObject * obj0 = 0 ;
33601 PyObject * obj1 = 0 ;
33602 char * kwnames[] = {
33603 (char *) "self",(char *) "handler", NULL
33604 };
33605
33606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33608 if (!SWIG_IsOK(res1)) {
33609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33610 }
33611 arg1 = reinterpret_cast< wxWindow * >(argp1);
33612 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33613 if (!SWIG_IsOK(res2)) {
33614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33615 }
33616 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 (arg1)->SetEventHandler(arg2);
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 resultobj = SWIG_Py_Void();
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj = 0;
33632 wxWindow *arg1 = (wxWindow *) 0 ;
33633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33634 void *argp1 = 0 ;
33635 int res1 = 0 ;
33636 void *argp2 = 0 ;
33637 int res2 = 0 ;
33638 PyObject * obj0 = 0 ;
33639 PyObject * obj1 = 0 ;
33640 char * kwnames[] = {
33641 (char *) "self",(char *) "handler", NULL
33642 };
33643
33644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33646 if (!SWIG_IsOK(res1)) {
33647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33648 }
33649 arg1 = reinterpret_cast< wxWindow * >(argp1);
33650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33651 if (!SWIG_IsOK(res2)) {
33652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33653 }
33654 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 (arg1)->PushEventHandler(arg2);
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_Py_Void();
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 bool arg2 = (bool) false ;
33672 wxEvtHandler *result = 0 ;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 bool val2 ;
33676 int ecode2 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 char * kwnames[] = {
33680 (char *) "self",(char *) "deleteHandler", NULL
33681 };
33682
33683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33685 if (!SWIG_IsOK(res1)) {
33686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33687 }
33688 arg1 = reinterpret_cast< wxWindow * >(argp1);
33689 if (obj1) {
33690 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33691 if (!SWIG_IsOK(ecode2)) {
33692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33693 }
33694 arg2 = static_cast< bool >(val2);
33695 }
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 {
33703 resultobj = wxPyMake_wxObject(result, 0);
33704 }
33705 return resultobj;
33706 fail:
33707 return NULL;
33708 }
33709
33710
33711 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33712 PyObject *resultobj = 0;
33713 wxWindow *arg1 = (wxWindow *) 0 ;
33714 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33715 bool result;
33716 void *argp1 = 0 ;
33717 int res1 = 0 ;
33718 void *argp2 = 0 ;
33719 int res2 = 0 ;
33720 PyObject * obj0 = 0 ;
33721 PyObject * obj1 = 0 ;
33722 char * kwnames[] = {
33723 (char *) "self",(char *) "handler", NULL
33724 };
33725
33726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33728 if (!SWIG_IsOK(res1)) {
33729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33730 }
33731 arg1 = reinterpret_cast< wxWindow * >(argp1);
33732 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33733 if (!SWIG_IsOK(res2)) {
33734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33735 }
33736 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33737 {
33738 PyThreadState* __tstate = wxPyBeginAllowThreads();
33739 result = (bool)(arg1)->RemoveEventHandler(arg2);
33740 wxPyEndAllowThreads(__tstate);
33741 if (PyErr_Occurred()) SWIG_fail;
33742 }
33743 {
33744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33745 }
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxWindow *arg1 = (wxWindow *) 0 ;
33755 wxValidator *arg2 = 0 ;
33756 void *argp1 = 0 ;
33757 int res1 = 0 ;
33758 void *argp2 = 0 ;
33759 int res2 = 0 ;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char * kwnames[] = {
33763 (char *) "self",(char *) "validator", NULL
33764 };
33765
33766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33768 if (!SWIG_IsOK(res1)) {
33769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33770 }
33771 arg1 = reinterpret_cast< wxWindow * >(argp1);
33772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33773 if (!SWIG_IsOK(res2)) {
33774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33775 }
33776 if (!argp2) {
33777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33778 }
33779 arg2 = reinterpret_cast< wxValidator * >(argp2);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 (arg1)->SetValidator((wxValidator const &)*arg2);
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 resultobj = SWIG_Py_Void();
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33794 PyObject *resultobj = 0;
33795 wxWindow *arg1 = (wxWindow *) 0 ;
33796 wxValidator *result = 0 ;
33797 void *argp1 = 0 ;
33798 int res1 = 0 ;
33799 PyObject *swig_obj[1] ;
33800
33801 if (!args) SWIG_fail;
33802 swig_obj[0] = args;
33803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33806 }
33807 arg1 = reinterpret_cast< wxWindow * >(argp1);
33808 {
33809 PyThreadState* __tstate = wxPyBeginAllowThreads();
33810 result = (wxValidator *)(arg1)->GetValidator();
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 {
33815 resultobj = wxPyMake_wxObject(result, (bool)0);
33816 }
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33824 PyObject *resultobj = 0;
33825 wxWindow *arg1 = (wxWindow *) 0 ;
33826 bool result;
33827 void *argp1 = 0 ;
33828 int res1 = 0 ;
33829 PyObject *swig_obj[1] ;
33830
33831 if (!args) SWIG_fail;
33832 swig_obj[0] = args;
33833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33834 if (!SWIG_IsOK(res1)) {
33835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33836 }
33837 arg1 = reinterpret_cast< wxWindow * >(argp1);
33838 {
33839 PyThreadState* __tstate = wxPyBeginAllowThreads();
33840 result = (bool)(arg1)->Validate();
33841 wxPyEndAllowThreads(__tstate);
33842 if (PyErr_Occurred()) SWIG_fail;
33843 }
33844 {
33845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33846 }
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33854 PyObject *resultobj = 0;
33855 wxWindow *arg1 = (wxWindow *) 0 ;
33856 bool result;
33857 void *argp1 = 0 ;
33858 int res1 = 0 ;
33859 PyObject *swig_obj[1] ;
33860
33861 if (!args) SWIG_fail;
33862 swig_obj[0] = args;
33863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33864 if (!SWIG_IsOK(res1)) {
33865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33866 }
33867 arg1 = reinterpret_cast< wxWindow * >(argp1);
33868 {
33869 PyThreadState* __tstate = wxPyBeginAllowThreads();
33870 result = (bool)(arg1)->TransferDataToWindow();
33871 wxPyEndAllowThreads(__tstate);
33872 if (PyErr_Occurred()) SWIG_fail;
33873 }
33874 {
33875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33876 }
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 bool result;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)(arg1)->TransferDataFromWindow();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 PyObject *swig_obj[1] ;
33919
33920 if (!args) SWIG_fail;
33921 swig_obj[0] = args;
33922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33923 if (!SWIG_IsOK(res1)) {
33924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33925 }
33926 arg1 = reinterpret_cast< wxWindow * >(argp1);
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->InitDialog();
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 wxAcceleratorTable *arg2 = 0 ;
33944 void *argp1 = 0 ;
33945 int res1 = 0 ;
33946 void *argp2 = 0 ;
33947 int res2 = 0 ;
33948 PyObject * obj0 = 0 ;
33949 PyObject * obj1 = 0 ;
33950 char * kwnames[] = {
33951 (char *) "self",(char *) "accel", NULL
33952 };
33953
33954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33956 if (!SWIG_IsOK(res1)) {
33957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33958 }
33959 arg1 = reinterpret_cast< wxWindow * >(argp1);
33960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33961 if (!SWIG_IsOK(res2)) {
33962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33963 }
33964 if (!argp2) {
33965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33966 }
33967 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_Py_Void();
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33982 PyObject *resultobj = 0;
33983 wxWindow *arg1 = (wxWindow *) 0 ;
33984 wxAcceleratorTable *result = 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 PyObject *swig_obj[1] ;
33988
33989 if (!args) SWIG_fail;
33990 swig_obj[0] = args;
33991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33994 }
33995 arg1 = reinterpret_cast< wxWindow * >(argp1);
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33999 wxPyEndAllowThreads(__tstate);
34000 if (PyErr_Occurred()) SWIG_fail;
34001 }
34002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34003 return resultobj;
34004 fail:
34005 return NULL;
34006 }
34007
34008
34009 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34010 PyObject *resultobj = 0;
34011 wxWindow *arg1 = (wxWindow *) 0 ;
34012 int arg2 ;
34013 int arg3 ;
34014 int arg4 ;
34015 bool result;
34016 void *argp1 = 0 ;
34017 int res1 = 0 ;
34018 int val2 ;
34019 int ecode2 = 0 ;
34020 int val3 ;
34021 int ecode3 = 0 ;
34022 int val4 ;
34023 int ecode4 = 0 ;
34024 PyObject * obj0 = 0 ;
34025 PyObject * obj1 = 0 ;
34026 PyObject * obj2 = 0 ;
34027 PyObject * obj3 = 0 ;
34028 char * kwnames[] = {
34029 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34030 };
34031
34032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34034 if (!SWIG_IsOK(res1)) {
34035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34036 }
34037 arg1 = reinterpret_cast< wxWindow * >(argp1);
34038 ecode2 = SWIG_AsVal_int(obj1, &val2);
34039 if (!SWIG_IsOK(ecode2)) {
34040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34041 }
34042 arg2 = static_cast< int >(val2);
34043 ecode3 = SWIG_AsVal_int(obj2, &val3);
34044 if (!SWIG_IsOK(ecode3)) {
34045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34046 }
34047 arg3 = static_cast< int >(val3);
34048 ecode4 = SWIG_AsVal_int(obj3, &val4);
34049 if (!SWIG_IsOK(ecode4)) {
34050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34051 }
34052 arg4 = static_cast< int >(val4);
34053 {
34054 PyThreadState* __tstate = wxPyBeginAllowThreads();
34055 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 {
34060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34061 }
34062 return resultobj;
34063 fail:
34064 return NULL;
34065 }
34066
34067
34068 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34069 PyObject *resultobj = 0;
34070 wxWindow *arg1 = (wxWindow *) 0 ;
34071 int arg2 ;
34072 bool result;
34073 void *argp1 = 0 ;
34074 int res1 = 0 ;
34075 int val2 ;
34076 int ecode2 = 0 ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 char * kwnames[] = {
34080 (char *) "self",(char *) "hotkeyId", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 ecode2 = SWIG_AsVal_int(obj1, &val2);
34090 if (!SWIG_IsOK(ecode2)) {
34091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34092 }
34093 arg2 = static_cast< int >(val2);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 {
34101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34102 }
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34110 PyObject *resultobj = 0;
34111 wxWindow *arg1 = (wxWindow *) 0 ;
34112 wxPoint *arg2 = 0 ;
34113 wxPoint result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 wxPoint temp2 ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 char * kwnames[] = {
34120 (char *) "self",(char *) "pt", NULL
34121 };
34122
34123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34125 if (!SWIG_IsOK(res1)) {
34126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34127 }
34128 arg1 = reinterpret_cast< wxWindow * >(argp1);
34129 {
34130 arg2 = &temp2;
34131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34132 }
34133 {
34134 PyThreadState* __tstate = wxPyBeginAllowThreads();
34135 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34136 wxPyEndAllowThreads(__tstate);
34137 if (PyErr_Occurred()) SWIG_fail;
34138 }
34139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj = 0;
34148 wxWindow *arg1 = (wxWindow *) 0 ;
34149 wxSize *arg2 = 0 ;
34150 wxSize result;
34151 void *argp1 = 0 ;
34152 int res1 = 0 ;
34153 wxSize temp2 ;
34154 PyObject * obj0 = 0 ;
34155 PyObject * obj1 = 0 ;
34156 char * kwnames[] = {
34157 (char *) "self",(char *) "sz", NULL
34158 };
34159
34160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34162 if (!SWIG_IsOK(res1)) {
34163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34164 }
34165 arg1 = reinterpret_cast< wxWindow * >(argp1);
34166 {
34167 arg2 = &temp2;
34168 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34169 }
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 wxPoint *arg2 = 0 ;
34187 wxPoint result;
34188 void *argp1 = 0 ;
34189 int res1 = 0 ;
34190 wxPoint temp2 ;
34191 PyObject * obj0 = 0 ;
34192 PyObject * obj1 = 0 ;
34193 char * kwnames[] = {
34194 (char *) "self",(char *) "pt", NULL
34195 };
34196
34197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34199 if (!SWIG_IsOK(res1)) {
34200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34201 }
34202 arg1 = reinterpret_cast< wxWindow * >(argp1);
34203 {
34204 arg2 = &temp2;
34205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34206 }
34207 {
34208 PyThreadState* __tstate = wxPyBeginAllowThreads();
34209 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34221 PyObject *resultobj = 0;
34222 wxWindow *arg1 = (wxWindow *) 0 ;
34223 wxSize *arg2 = 0 ;
34224 wxSize result;
34225 void *argp1 = 0 ;
34226 int res1 = 0 ;
34227 wxSize temp2 ;
34228 PyObject * obj0 = 0 ;
34229 PyObject * obj1 = 0 ;
34230 char * kwnames[] = {
34231 (char *) "self",(char *) "sz", NULL
34232 };
34233
34234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 arg2 = &temp2;
34242 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34243 }
34244 {
34245 PyThreadState* __tstate = wxPyBeginAllowThreads();
34246 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34247 wxPyEndAllowThreads(__tstate);
34248 if (PyErr_Occurred()) SWIG_fail;
34249 }
34250 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34251 return resultobj;
34252 fail:
34253 return NULL;
34254 }
34255
34256
34257 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34258 PyObject *resultobj = 0;
34259 wxWindow *arg1 = (wxWindow *) 0 ;
34260 wxPoint *arg2 = 0 ;
34261 wxPoint result;
34262 void *argp1 = 0 ;
34263 int res1 = 0 ;
34264 wxPoint temp2 ;
34265 PyObject * obj0 = 0 ;
34266 PyObject * obj1 = 0 ;
34267 char * kwnames[] = {
34268 (char *) "self",(char *) "pt", NULL
34269 };
34270
34271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34273 if (!SWIG_IsOK(res1)) {
34274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34275 }
34276 arg1 = reinterpret_cast< wxWindow * >(argp1);
34277 {
34278 arg2 = &temp2;
34279 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34280 }
34281 {
34282 PyThreadState* __tstate = wxPyBeginAllowThreads();
34283 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34284 wxPyEndAllowThreads(__tstate);
34285 if (PyErr_Occurred()) SWIG_fail;
34286 }
34287 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34288 return resultobj;
34289 fail:
34290 return NULL;
34291 }
34292
34293
34294 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34295 PyObject *resultobj = 0;
34296 wxWindow *arg1 = (wxWindow *) 0 ;
34297 wxSize *arg2 = 0 ;
34298 wxSize result;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 wxSize temp2 ;
34302 PyObject * obj0 = 0 ;
34303 PyObject * obj1 = 0 ;
34304 char * kwnames[] = {
34305 (char *) "self",(char *) "sz", NULL
34306 };
34307
34308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34312 }
34313 arg1 = reinterpret_cast< wxWindow * >(argp1);
34314 {
34315 arg2 = &temp2;
34316 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34317 }
34318 {
34319 PyThreadState* __tstate = wxPyBeginAllowThreads();
34320 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34321 wxPyEndAllowThreads(__tstate);
34322 if (PyErr_Occurred()) SWIG_fail;
34323 }
34324 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34325 return resultobj;
34326 fail:
34327 return NULL;
34328 }
34329
34330
34331 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34332 PyObject *resultobj = 0;
34333 wxWindow *arg1 = (wxWindow *) 0 ;
34334 int arg2 ;
34335 int arg3 ;
34336 void *argp1 = 0 ;
34337 int res1 = 0 ;
34338 int val2 ;
34339 int ecode2 = 0 ;
34340 int val3 ;
34341 int ecode3 = 0 ;
34342 PyObject * obj0 = 0 ;
34343 PyObject * obj1 = 0 ;
34344 PyObject * obj2 = 0 ;
34345 char * kwnames[] = {
34346 (char *) "self",(char *) "x",(char *) "y", NULL
34347 };
34348
34349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34351 if (!SWIG_IsOK(res1)) {
34352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34353 }
34354 arg1 = reinterpret_cast< wxWindow * >(argp1);
34355 ecode2 = SWIG_AsVal_int(obj1, &val2);
34356 if (!SWIG_IsOK(ecode2)) {
34357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34358 }
34359 arg2 = static_cast< int >(val2);
34360 ecode3 = SWIG_AsVal_int(obj2, &val3);
34361 if (!SWIG_IsOK(ecode3)) {
34362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34363 }
34364 arg3 = static_cast< int >(val3);
34365 {
34366 PyThreadState* __tstate = wxPyBeginAllowThreads();
34367 (arg1)->WarpPointer(arg2,arg3);
34368 wxPyEndAllowThreads(__tstate);
34369 if (PyErr_Occurred()) SWIG_fail;
34370 }
34371 resultobj = SWIG_Py_Void();
34372 return resultobj;
34373 fail:
34374 return NULL;
34375 }
34376
34377
34378 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34379 PyObject *resultobj = 0;
34380 wxWindow *arg1 = (wxWindow *) 0 ;
34381 void *argp1 = 0 ;
34382 int res1 = 0 ;
34383 PyObject *swig_obj[1] ;
34384
34385 if (!args) SWIG_fail;
34386 swig_obj[0] = args;
34387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34388 if (!SWIG_IsOK(res1)) {
34389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34390 }
34391 arg1 = reinterpret_cast< wxWindow * >(argp1);
34392 {
34393 PyThreadState* __tstate = wxPyBeginAllowThreads();
34394 (arg1)->CaptureMouse();
34395 wxPyEndAllowThreads(__tstate);
34396 if (PyErr_Occurred()) SWIG_fail;
34397 }
34398 resultobj = SWIG_Py_Void();
34399 return resultobj;
34400 fail:
34401 return NULL;
34402 }
34403
34404
34405 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34406 PyObject *resultobj = 0;
34407 wxWindow *arg1 = (wxWindow *) 0 ;
34408 void *argp1 = 0 ;
34409 int res1 = 0 ;
34410 PyObject *swig_obj[1] ;
34411
34412 if (!args) SWIG_fail;
34413 swig_obj[0] = args;
34414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34415 if (!SWIG_IsOK(res1)) {
34416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34417 }
34418 arg1 = reinterpret_cast< wxWindow * >(argp1);
34419 {
34420 PyThreadState* __tstate = wxPyBeginAllowThreads();
34421 (arg1)->ReleaseMouse();
34422 wxPyEndAllowThreads(__tstate);
34423 if (PyErr_Occurred()) SWIG_fail;
34424 }
34425 resultobj = SWIG_Py_Void();
34426 return resultobj;
34427 fail:
34428 return NULL;
34429 }
34430
34431
34432 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34433 PyObject *resultobj = 0;
34434 wxWindow *result = 0 ;
34435
34436 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34437 {
34438 if (!wxPyCheckForApp()) SWIG_fail;
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 result = (wxWindow *)wxWindow::GetCapture();
34441 wxPyEndAllowThreads(__tstate);
34442 if (PyErr_Occurred()) SWIG_fail;
34443 }
34444 {
34445 resultobj = wxPyMake_wxObject(result, 0);
34446 }
34447 return resultobj;
34448 fail:
34449 return NULL;
34450 }
34451
34452
34453 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34454 PyObject *resultobj = 0;
34455 wxWindow *arg1 = (wxWindow *) 0 ;
34456 bool result;
34457 void *argp1 = 0 ;
34458 int res1 = 0 ;
34459 PyObject *swig_obj[1] ;
34460
34461 if (!args) SWIG_fail;
34462 swig_obj[0] = args;
34463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34464 if (!SWIG_IsOK(res1)) {
34465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34466 }
34467 arg1 = reinterpret_cast< wxWindow * >(argp1);
34468 {
34469 PyThreadState* __tstate = wxPyBeginAllowThreads();
34470 result = (bool)((wxWindow const *)arg1)->HasCapture();
34471 wxPyEndAllowThreads(__tstate);
34472 if (PyErr_Occurred()) SWIG_fail;
34473 }
34474 {
34475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34476 }
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 bool arg2 = (bool) true ;
34487 wxRect *arg3 = (wxRect *) NULL ;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 bool val2 ;
34491 int ecode2 = 0 ;
34492 void *argp3 = 0 ;
34493 int res3 = 0 ;
34494 PyObject * obj0 = 0 ;
34495 PyObject * obj1 = 0 ;
34496 PyObject * obj2 = 0 ;
34497 char * kwnames[] = {
34498 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34499 };
34500
34501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34503 if (!SWIG_IsOK(res1)) {
34504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34505 }
34506 arg1 = reinterpret_cast< wxWindow * >(argp1);
34507 if (obj1) {
34508 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34509 if (!SWIG_IsOK(ecode2)) {
34510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34511 }
34512 arg2 = static_cast< bool >(val2);
34513 }
34514 if (obj2) {
34515 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34516 if (!SWIG_IsOK(res3)) {
34517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34518 }
34519 arg3 = reinterpret_cast< wxRect * >(argp3);
34520 }
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 resultobj = SWIG_Py_Void();
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34535 PyObject *resultobj = 0;
34536 wxWindow *arg1 = (wxWindow *) 0 ;
34537 wxRect *arg2 = 0 ;
34538 bool arg3 = (bool) true ;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 wxRect temp2 ;
34542 bool val3 ;
34543 int ecode3 = 0 ;
34544 PyObject * obj0 = 0 ;
34545 PyObject * obj1 = 0 ;
34546 PyObject * obj2 = 0 ;
34547 char * kwnames[] = {
34548 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34549 };
34550
34551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34553 if (!SWIG_IsOK(res1)) {
34554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34555 }
34556 arg1 = reinterpret_cast< wxWindow * >(argp1);
34557 {
34558 arg2 = &temp2;
34559 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34560 }
34561 if (obj2) {
34562 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34563 if (!SWIG_IsOK(ecode3)) {
34564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34565 }
34566 arg3 = static_cast< bool >(val3);
34567 }
34568 {
34569 PyThreadState* __tstate = wxPyBeginAllowThreads();
34570 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34571 wxPyEndAllowThreads(__tstate);
34572 if (PyErr_Occurred()) SWIG_fail;
34573 }
34574 resultobj = SWIG_Py_Void();
34575 return resultobj;
34576 fail:
34577 return NULL;
34578 }
34579
34580
34581 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34582 PyObject *resultobj = 0;
34583 wxWindow *arg1 = (wxWindow *) 0 ;
34584 void *argp1 = 0 ;
34585 int res1 = 0 ;
34586 PyObject *swig_obj[1] ;
34587
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 (arg1)->Update();
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 resultobj = SWIG_Py_Void();
34602 return resultobj;
34603 fail:
34604 return NULL;
34605 }
34606
34607
34608 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34609 PyObject *resultobj = 0;
34610 wxWindow *arg1 = (wxWindow *) 0 ;
34611 void *argp1 = 0 ;
34612 int res1 = 0 ;
34613 PyObject *swig_obj[1] ;
34614
34615 if (!args) SWIG_fail;
34616 swig_obj[0] = args;
34617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34618 if (!SWIG_IsOK(res1)) {
34619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34620 }
34621 arg1 = reinterpret_cast< wxWindow * >(argp1);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 (arg1)->ClearBackground();
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_Py_Void();
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34636 PyObject *resultobj = 0;
34637 wxWindow *arg1 = (wxWindow *) 0 ;
34638 void *argp1 = 0 ;
34639 int res1 = 0 ;
34640 PyObject *swig_obj[1] ;
34641
34642 if (!args) SWIG_fail;
34643 swig_obj[0] = args;
34644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34645 if (!SWIG_IsOK(res1)) {
34646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34647 }
34648 arg1 = reinterpret_cast< wxWindow * >(argp1);
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 (arg1)->Freeze();
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_Py_Void();
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34663 PyObject *resultobj = 0;
34664 wxWindow *arg1 = (wxWindow *) 0 ;
34665 void *argp1 = 0 ;
34666 int res1 = 0 ;
34667 PyObject *swig_obj[1] ;
34668
34669 if (!args) SWIG_fail;
34670 swig_obj[0] = args;
34671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34672 if (!SWIG_IsOK(res1)) {
34673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34674 }
34675 arg1 = reinterpret_cast< wxWindow * >(argp1);
34676 {
34677 PyThreadState* __tstate = wxPyBeginAllowThreads();
34678 (arg1)->Thaw();
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 resultobj = SWIG_Py_Void();
34683 return resultobj;
34684 fail:
34685 return NULL;
34686 }
34687
34688
34689 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34690 PyObject *resultobj = 0;
34691 wxWindow *arg1 = (wxWindow *) 0 ;
34692 wxDC *arg2 = 0 ;
34693 void *argp1 = 0 ;
34694 int res1 = 0 ;
34695 void *argp2 = 0 ;
34696 int res2 = 0 ;
34697 PyObject * obj0 = 0 ;
34698 PyObject * obj1 = 0 ;
34699 char * kwnames[] = {
34700 (char *) "self",(char *) "dc", NULL
34701 };
34702
34703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34705 if (!SWIG_IsOK(res1)) {
34706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34707 }
34708 arg1 = reinterpret_cast< wxWindow * >(argp1);
34709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34710 if (!SWIG_IsOK(res2)) {
34711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34712 }
34713 if (!argp2) {
34714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34715 }
34716 arg2 = reinterpret_cast< wxDC * >(argp2);
34717 {
34718 PyThreadState* __tstate = wxPyBeginAllowThreads();
34719 (arg1)->PrepareDC(*arg2);
34720 wxPyEndAllowThreads(__tstate);
34721 if (PyErr_Occurred()) SWIG_fail;
34722 }
34723 resultobj = SWIG_Py_Void();
34724 return resultobj;
34725 fail:
34726 return NULL;
34727 }
34728
34729
34730 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34731 PyObject *resultobj = 0;
34732 wxWindow *arg1 = (wxWindow *) 0 ;
34733 wxRegion *result = 0 ;
34734 void *argp1 = 0 ;
34735 int res1 = 0 ;
34736 PyObject *swig_obj[1] ;
34737
34738 if (!args) SWIG_fail;
34739 swig_obj[0] = args;
34740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34741 if (!SWIG_IsOK(res1)) {
34742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34743 }
34744 arg1 = reinterpret_cast< wxWindow * >(argp1);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 {
34748 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34749 result = (wxRegion *) &_result_ref;
34750 }
34751 wxPyEndAllowThreads(__tstate);
34752 if (PyErr_Occurred()) SWIG_fail;
34753 }
34754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34755 return resultobj;
34756 fail:
34757 return NULL;
34758 }
34759
34760
34761 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34762 PyObject *resultobj = 0;
34763 wxWindow *arg1 = (wxWindow *) 0 ;
34764 wxRect result;
34765 void *argp1 = 0 ;
34766 int res1 = 0 ;
34767 PyObject *swig_obj[1] ;
34768
34769 if (!args) SWIG_fail;
34770 swig_obj[0] = args;
34771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34772 if (!SWIG_IsOK(res1)) {
34773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34774 }
34775 arg1 = reinterpret_cast< wxWindow * >(argp1);
34776 {
34777 PyThreadState* __tstate = wxPyBeginAllowThreads();
34778 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34779 wxPyEndAllowThreads(__tstate);
34780 if (PyErr_Occurred()) SWIG_fail;
34781 }
34782 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34783 return resultobj;
34784 fail:
34785 return NULL;
34786 }
34787
34788
34789 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34790 PyObject *resultobj = 0;
34791 wxWindow *arg1 = (wxWindow *) 0 ;
34792 int arg2 ;
34793 int arg3 ;
34794 int arg4 = (int) 1 ;
34795 int arg5 = (int) 1 ;
34796 bool result;
34797 void *argp1 = 0 ;
34798 int res1 = 0 ;
34799 int val2 ;
34800 int ecode2 = 0 ;
34801 int val3 ;
34802 int ecode3 = 0 ;
34803 int val4 ;
34804 int ecode4 = 0 ;
34805 int val5 ;
34806 int ecode5 = 0 ;
34807 PyObject * obj0 = 0 ;
34808 PyObject * obj1 = 0 ;
34809 PyObject * obj2 = 0 ;
34810 PyObject * obj3 = 0 ;
34811 PyObject * obj4 = 0 ;
34812 char * kwnames[] = {
34813 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34814 };
34815
34816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34818 if (!SWIG_IsOK(res1)) {
34819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34820 }
34821 arg1 = reinterpret_cast< wxWindow * >(argp1);
34822 ecode2 = SWIG_AsVal_int(obj1, &val2);
34823 if (!SWIG_IsOK(ecode2)) {
34824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34825 }
34826 arg2 = static_cast< int >(val2);
34827 ecode3 = SWIG_AsVal_int(obj2, &val3);
34828 if (!SWIG_IsOK(ecode3)) {
34829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34830 }
34831 arg3 = static_cast< int >(val3);
34832 if (obj3) {
34833 ecode4 = SWIG_AsVal_int(obj3, &val4);
34834 if (!SWIG_IsOK(ecode4)) {
34835 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34836 }
34837 arg4 = static_cast< int >(val4);
34838 }
34839 if (obj4) {
34840 ecode5 = SWIG_AsVal_int(obj4, &val5);
34841 if (!SWIG_IsOK(ecode5)) {
34842 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34843 }
34844 arg5 = static_cast< int >(val5);
34845 }
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34849 wxPyEndAllowThreads(__tstate);
34850 if (PyErr_Occurred()) SWIG_fail;
34851 }
34852 {
34853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34854 }
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 wxPoint *arg2 = 0 ;
34865 bool result;
34866 void *argp1 = 0 ;
34867 int res1 = 0 ;
34868 wxPoint temp2 ;
34869 PyObject * obj0 = 0 ;
34870 PyObject * obj1 = 0 ;
34871 char * kwnames[] = {
34872 (char *) "self",(char *) "pt", NULL
34873 };
34874
34875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 {
34882 arg2 = &temp2;
34883 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34884 }
34885 {
34886 PyThreadState* __tstate = wxPyBeginAllowThreads();
34887 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34888 wxPyEndAllowThreads(__tstate);
34889 if (PyErr_Occurred()) SWIG_fail;
34890 }
34891 {
34892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34893 }
34894 return resultobj;
34895 fail:
34896 return NULL;
34897 }
34898
34899
34900 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34901 PyObject *resultobj = 0;
34902 wxWindow *arg1 = (wxWindow *) 0 ;
34903 wxRect *arg2 = 0 ;
34904 bool result;
34905 void *argp1 = 0 ;
34906 int res1 = 0 ;
34907 wxRect temp2 ;
34908 PyObject * obj0 = 0 ;
34909 PyObject * obj1 = 0 ;
34910 char * kwnames[] = {
34911 (char *) "self",(char *) "rect", NULL
34912 };
34913
34914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34916 if (!SWIG_IsOK(res1)) {
34917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34918 }
34919 arg1 = reinterpret_cast< wxWindow * >(argp1);
34920 {
34921 arg2 = &temp2;
34922 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34923 }
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 {
34931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34932 }
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34940 PyObject *resultobj = 0;
34941 wxWindow *arg1 = (wxWindow *) 0 ;
34942 SwigValueWrapper<wxVisualAttributes > result;
34943 void *argp1 = 0 ;
34944 int res1 = 0 ;
34945 PyObject *swig_obj[1] ;
34946
34947 if (!args) SWIG_fail;
34948 swig_obj[0] = args;
34949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34950 if (!SWIG_IsOK(res1)) {
34951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34952 }
34953 arg1 = reinterpret_cast< wxWindow * >(argp1);
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34957 wxPyEndAllowThreads(__tstate);
34958 if (PyErr_Occurred()) SWIG_fail;
34959 }
34960 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34961 return resultobj;
34962 fail:
34963 return NULL;
34964 }
34965
34966
34967 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34968 PyObject *resultobj = 0;
34969 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34970 SwigValueWrapper<wxVisualAttributes > result;
34971 int val1 ;
34972 int ecode1 = 0 ;
34973 PyObject * obj0 = 0 ;
34974 char * kwnames[] = {
34975 (char *) "variant", NULL
34976 };
34977
34978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34979 if (obj0) {
34980 ecode1 = SWIG_AsVal_int(obj0, &val1);
34981 if (!SWIG_IsOK(ecode1)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34983 }
34984 arg1 = static_cast< wxWindowVariant >(val1);
34985 }
34986 {
34987 if (!wxPyCheckForApp()) SWIG_fail;
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 result = wxWindow::GetClassDefaultAttributes(arg1);
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35001 PyObject *resultobj = 0;
35002 wxWindow *arg1 = (wxWindow *) 0 ;
35003 wxColour *arg2 = 0 ;
35004 bool result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 wxColour temp2 ;
35008 PyObject * obj0 = 0 ;
35009 PyObject * obj1 = 0 ;
35010 char * kwnames[] = {
35011 (char *) "self",(char *) "colour", NULL
35012 };
35013
35014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35018 }
35019 arg1 = reinterpret_cast< wxWindow * >(argp1);
35020 {
35021 arg2 = &temp2;
35022 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35023 }
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35027 wxPyEndAllowThreads(__tstate);
35028 if (PyErr_Occurred()) SWIG_fail;
35029 }
35030 {
35031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35032 }
35033 return resultobj;
35034 fail:
35035 return NULL;
35036 }
35037
35038
35039 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35040 PyObject *resultobj = 0;
35041 wxWindow *arg1 = (wxWindow *) 0 ;
35042 wxColour *arg2 = 0 ;
35043 void *argp1 = 0 ;
35044 int res1 = 0 ;
35045 wxColour temp2 ;
35046 PyObject * obj0 = 0 ;
35047 PyObject * obj1 = 0 ;
35048 char * kwnames[] = {
35049 (char *) "self",(char *) "colour", NULL
35050 };
35051
35052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35056 }
35057 arg1 = reinterpret_cast< wxWindow * >(argp1);
35058 {
35059 arg2 = &temp2;
35060 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35061 }
35062 {
35063 PyThreadState* __tstate = wxPyBeginAllowThreads();
35064 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 resultobj = SWIG_Py_Void();
35069 return resultobj;
35070 fail:
35071 return NULL;
35072 }
35073
35074
35075 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35076 PyObject *resultobj = 0;
35077 wxWindow *arg1 = (wxWindow *) 0 ;
35078 wxColour *arg2 = 0 ;
35079 bool result;
35080 void *argp1 = 0 ;
35081 int res1 = 0 ;
35082 wxColour temp2 ;
35083 PyObject * obj0 = 0 ;
35084 PyObject * obj1 = 0 ;
35085 char * kwnames[] = {
35086 (char *) "self",(char *) "colour", NULL
35087 };
35088
35089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35091 if (!SWIG_IsOK(res1)) {
35092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35093 }
35094 arg1 = reinterpret_cast< wxWindow * >(argp1);
35095 {
35096 arg2 = &temp2;
35097 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35098 }
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 {
35106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35107 }
35108 return resultobj;
35109 fail:
35110 return NULL;
35111 }
35112
35113
35114 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35115 PyObject *resultobj = 0;
35116 wxWindow *arg1 = (wxWindow *) 0 ;
35117 wxColour *arg2 = 0 ;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 wxColour temp2 ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char * kwnames[] = {
35124 (char *) "self",(char *) "colour", NULL
35125 };
35126
35127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 arg2 = &temp2;
35135 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_Py_Void();
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35151 PyObject *resultobj = 0;
35152 wxWindow *arg1 = (wxWindow *) 0 ;
35153 wxColour result;
35154 void *argp1 = 0 ;
35155 int res1 = 0 ;
35156 PyObject *swig_obj[1] ;
35157
35158 if (!args) SWIG_fail;
35159 swig_obj[0] = args;
35160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35161 if (!SWIG_IsOK(res1)) {
35162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35163 }
35164 arg1 = reinterpret_cast< wxWindow * >(argp1);
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35168 wxPyEndAllowThreads(__tstate);
35169 if (PyErr_Occurred()) SWIG_fail;
35170 }
35171 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35172 return resultobj;
35173 fail:
35174 return NULL;
35175 }
35176
35177
35178 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35179 PyObject *resultobj = 0;
35180 wxWindow *arg1 = (wxWindow *) 0 ;
35181 wxColour result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 PyObject *swig_obj[1] ;
35185
35186 if (!args) SWIG_fail;
35187 swig_obj[0] = args;
35188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35191 }
35192 arg1 = reinterpret_cast< wxWindow * >(argp1);
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 result = ((wxWindow const *)arg1)->GetForegroundColour();
35196 wxPyEndAllowThreads(__tstate);
35197 if (PyErr_Occurred()) SWIG_fail;
35198 }
35199 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35200 return resultobj;
35201 fail:
35202 return NULL;
35203 }
35204
35205
35206 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35207 PyObject *resultobj = 0;
35208 wxWindow *arg1 = (wxWindow *) 0 ;
35209 bool result;
35210 void *argp1 = 0 ;
35211 int res1 = 0 ;
35212 PyObject *swig_obj[1] ;
35213
35214 if (!args) SWIG_fail;
35215 swig_obj[0] = args;
35216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35217 if (!SWIG_IsOK(res1)) {
35218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35219 }
35220 arg1 = reinterpret_cast< wxWindow * >(argp1);
35221 {
35222 PyThreadState* __tstate = wxPyBeginAllowThreads();
35223 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35224 wxPyEndAllowThreads(__tstate);
35225 if (PyErr_Occurred()) SWIG_fail;
35226 }
35227 {
35228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35229 }
35230 return resultobj;
35231 fail:
35232 return NULL;
35233 }
35234
35235
35236 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35237 PyObject *resultobj = 0;
35238 wxWindow *arg1 = (wxWindow *) 0 ;
35239 bool result;
35240 void *argp1 = 0 ;
35241 int res1 = 0 ;
35242 PyObject *swig_obj[1] ;
35243
35244 if (!args) SWIG_fail;
35245 swig_obj[0] = args;
35246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35247 if (!SWIG_IsOK(res1)) {
35248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35249 }
35250 arg1 = reinterpret_cast< wxWindow * >(argp1);
35251 {
35252 PyThreadState* __tstate = wxPyBeginAllowThreads();
35253 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35254 wxPyEndAllowThreads(__tstate);
35255 if (PyErr_Occurred()) SWIG_fail;
35256 }
35257 {
35258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35259 }
35260 return resultobj;
35261 fail:
35262 return NULL;
35263 }
35264
35265
35266 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35267 PyObject *resultobj = 0;
35268 wxWindow *arg1 = (wxWindow *) 0 ;
35269 wxBackgroundStyle arg2 ;
35270 bool result;
35271 void *argp1 = 0 ;
35272 int res1 = 0 ;
35273 int val2 ;
35274 int ecode2 = 0 ;
35275 PyObject * obj0 = 0 ;
35276 PyObject * obj1 = 0 ;
35277 char * kwnames[] = {
35278 (char *) "self",(char *) "style", NULL
35279 };
35280
35281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35283 if (!SWIG_IsOK(res1)) {
35284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35285 }
35286 arg1 = reinterpret_cast< wxWindow * >(argp1);
35287 ecode2 = SWIG_AsVal_int(obj1, &val2);
35288 if (!SWIG_IsOK(ecode2)) {
35289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35290 }
35291 arg2 = static_cast< wxBackgroundStyle >(val2);
35292 {
35293 PyThreadState* __tstate = wxPyBeginAllowThreads();
35294 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35295 wxPyEndAllowThreads(__tstate);
35296 if (PyErr_Occurred()) SWIG_fail;
35297 }
35298 {
35299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35300 }
35301 return resultobj;
35302 fail:
35303 return NULL;
35304 }
35305
35306
35307 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35308 PyObject *resultobj = 0;
35309 wxWindow *arg1 = (wxWindow *) 0 ;
35310 wxBackgroundStyle result;
35311 void *argp1 = 0 ;
35312 int res1 = 0 ;
35313 PyObject *swig_obj[1] ;
35314
35315 if (!args) SWIG_fail;
35316 swig_obj[0] = args;
35317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35320 }
35321 arg1 = reinterpret_cast< wxWindow * >(argp1);
35322 {
35323 PyThreadState* __tstate = wxPyBeginAllowThreads();
35324 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35325 wxPyEndAllowThreads(__tstate);
35326 if (PyErr_Occurred()) SWIG_fail;
35327 }
35328 resultobj = SWIG_From_int(static_cast< int >(result));
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35336 PyObject *resultobj = 0;
35337 wxWindow *arg1 = (wxWindow *) 0 ;
35338 bool result;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 PyObject *swig_obj[1] ;
35342
35343 if (!args) SWIG_fail;
35344 swig_obj[0] = args;
35345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35348 }
35349 arg1 = reinterpret_cast< wxWindow * >(argp1);
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (bool)(arg1)->HasTransparentBackground();
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 {
35357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35358 }
35359 return resultobj;
35360 fail:
35361 return NULL;
35362 }
35363
35364
35365 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35366 PyObject *resultobj = 0;
35367 wxWindow *arg1 = (wxWindow *) 0 ;
35368 wxCursor *arg2 = 0 ;
35369 bool result;
35370 void *argp1 = 0 ;
35371 int res1 = 0 ;
35372 void *argp2 = 0 ;
35373 int res2 = 0 ;
35374 PyObject * obj0 = 0 ;
35375 PyObject * obj1 = 0 ;
35376 char * kwnames[] = {
35377 (char *) "self",(char *) "cursor", NULL
35378 };
35379
35380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35387 if (!SWIG_IsOK(res2)) {
35388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35389 }
35390 if (!argp2) {
35391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35392 }
35393 arg2 = reinterpret_cast< wxCursor * >(argp2);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 {
35401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35402 }
35403 return resultobj;
35404 fail:
35405 return NULL;
35406 }
35407
35408
35409 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35410 PyObject *resultobj = 0;
35411 wxWindow *arg1 = (wxWindow *) 0 ;
35412 wxCursor result;
35413 void *argp1 = 0 ;
35414 int res1 = 0 ;
35415 PyObject *swig_obj[1] ;
35416
35417 if (!args) SWIG_fail;
35418 swig_obj[0] = args;
35419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35420 if (!SWIG_IsOK(res1)) {
35421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35422 }
35423 arg1 = reinterpret_cast< wxWindow * >(argp1);
35424 {
35425 PyThreadState* __tstate = wxPyBeginAllowThreads();
35426 result = (arg1)->GetCursor();
35427 wxPyEndAllowThreads(__tstate);
35428 if (PyErr_Occurred()) SWIG_fail;
35429 }
35430 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35431 return resultobj;
35432 fail:
35433 return NULL;
35434 }
35435
35436
35437 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35438 PyObject *resultobj = 0;
35439 wxWindow *arg1 = (wxWindow *) 0 ;
35440 wxFont *arg2 = 0 ;
35441 bool result;
35442 void *argp1 = 0 ;
35443 int res1 = 0 ;
35444 void *argp2 = 0 ;
35445 int res2 = 0 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 char * kwnames[] = {
35449 (char *) "self",(char *) "font", NULL
35450 };
35451
35452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35454 if (!SWIG_IsOK(res1)) {
35455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35456 }
35457 arg1 = reinterpret_cast< wxWindow * >(argp1);
35458 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35459 if (!SWIG_IsOK(res2)) {
35460 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35461 }
35462 if (!argp2) {
35463 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35464 }
35465 arg2 = reinterpret_cast< wxFont * >(argp2);
35466 {
35467 PyThreadState* __tstate = wxPyBeginAllowThreads();
35468 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35469 wxPyEndAllowThreads(__tstate);
35470 if (PyErr_Occurred()) SWIG_fail;
35471 }
35472 {
35473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35474 }
35475 return resultobj;
35476 fail:
35477 return NULL;
35478 }
35479
35480
35481 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35482 PyObject *resultobj = 0;
35483 wxWindow *arg1 = (wxWindow *) 0 ;
35484 wxFont *arg2 = 0 ;
35485 void *argp1 = 0 ;
35486 int res1 = 0 ;
35487 void *argp2 = 0 ;
35488 int res2 = 0 ;
35489 PyObject * obj0 = 0 ;
35490 PyObject * obj1 = 0 ;
35491 char * kwnames[] = {
35492 (char *) "self",(char *) "font", NULL
35493 };
35494
35495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35497 if (!SWIG_IsOK(res1)) {
35498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35499 }
35500 arg1 = reinterpret_cast< wxWindow * >(argp1);
35501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35502 if (!SWIG_IsOK(res2)) {
35503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35504 }
35505 if (!argp2) {
35506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35507 }
35508 arg2 = reinterpret_cast< wxFont * >(argp2);
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->SetOwnFont((wxFont const &)*arg2);
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_Py_Void();
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35523 PyObject *resultobj = 0;
35524 wxWindow *arg1 = (wxWindow *) 0 ;
35525 wxFont result;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 PyObject *swig_obj[1] ;
35529
35530 if (!args) SWIG_fail;
35531 swig_obj[0] = args;
35532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35533 if (!SWIG_IsOK(res1)) {
35534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35535 }
35536 arg1 = reinterpret_cast< wxWindow * >(argp1);
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 result = (arg1)->GetFont();
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35544 return resultobj;
35545 fail:
35546 return NULL;
35547 }
35548
35549
35550 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35551 PyObject *resultobj = 0;
35552 wxWindow *arg1 = (wxWindow *) 0 ;
35553 wxCaret *arg2 = (wxCaret *) 0 ;
35554 void *argp1 = 0 ;
35555 int res1 = 0 ;
35556 int res2 = 0 ;
35557 PyObject * obj0 = 0 ;
35558 PyObject * obj1 = 0 ;
35559 char * kwnames[] = {
35560 (char *) "self",(char *) "caret", NULL
35561 };
35562
35563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35565 if (!SWIG_IsOK(res1)) {
35566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35567 }
35568 arg1 = reinterpret_cast< wxWindow * >(argp1);
35569 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35570 if (!SWIG_IsOK(res2)) {
35571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35572 }
35573 {
35574 PyThreadState* __tstate = wxPyBeginAllowThreads();
35575 (arg1)->SetCaret(arg2);
35576 wxPyEndAllowThreads(__tstate);
35577 if (PyErr_Occurred()) SWIG_fail;
35578 }
35579 resultobj = SWIG_Py_Void();
35580 return resultobj;
35581 fail:
35582 return NULL;
35583 }
35584
35585
35586 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35587 PyObject *resultobj = 0;
35588 wxWindow *arg1 = (wxWindow *) 0 ;
35589 wxCaret *result = 0 ;
35590 void *argp1 = 0 ;
35591 int res1 = 0 ;
35592 PyObject *swig_obj[1] ;
35593
35594 if (!args) SWIG_fail;
35595 swig_obj[0] = args;
35596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35597 if (!SWIG_IsOK(res1)) {
35598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35599 }
35600 arg1 = reinterpret_cast< wxWindow * >(argp1);
35601 {
35602 PyThreadState* __tstate = wxPyBeginAllowThreads();
35603 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35604 wxPyEndAllowThreads(__tstate);
35605 if (PyErr_Occurred()) SWIG_fail;
35606 }
35607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35608 return resultobj;
35609 fail:
35610 return NULL;
35611 }
35612
35613
35614 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35615 PyObject *resultobj = 0;
35616 wxWindow *arg1 = (wxWindow *) 0 ;
35617 int result;
35618 void *argp1 = 0 ;
35619 int res1 = 0 ;
35620 PyObject *swig_obj[1] ;
35621
35622 if (!args) SWIG_fail;
35623 swig_obj[0] = args;
35624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35625 if (!SWIG_IsOK(res1)) {
35626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35627 }
35628 arg1 = reinterpret_cast< wxWindow * >(argp1);
35629 {
35630 PyThreadState* __tstate = wxPyBeginAllowThreads();
35631 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35632 wxPyEndAllowThreads(__tstate);
35633 if (PyErr_Occurred()) SWIG_fail;
35634 }
35635 resultobj = SWIG_From_int(static_cast< int >(result));
35636 return resultobj;
35637 fail:
35638 return NULL;
35639 }
35640
35641
35642 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35643 PyObject *resultobj = 0;
35644 wxWindow *arg1 = (wxWindow *) 0 ;
35645 int result;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 PyObject *swig_obj[1] ;
35649
35650 if (!args) SWIG_fail;
35651 swig_obj[0] = args;
35652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35653 if (!SWIG_IsOK(res1)) {
35654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35655 }
35656 arg1 = reinterpret_cast< wxWindow * >(argp1);
35657 {
35658 PyThreadState* __tstate = wxPyBeginAllowThreads();
35659 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 resultobj = SWIG_From_int(static_cast< int >(result));
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35671 PyObject *resultobj = 0;
35672 wxWindow *arg1 = (wxWindow *) 0 ;
35673 wxString *arg2 = 0 ;
35674 int *arg3 = (int *) 0 ;
35675 int *arg4 = (int *) 0 ;
35676 void *argp1 = 0 ;
35677 int res1 = 0 ;
35678 bool temp2 = false ;
35679 int temp3 ;
35680 int res3 = SWIG_TMPOBJ ;
35681 int temp4 ;
35682 int res4 = SWIG_TMPOBJ ;
35683 PyObject * obj0 = 0 ;
35684 PyObject * obj1 = 0 ;
35685 char * kwnames[] = {
35686 (char *) "self",(char *) "string", NULL
35687 };
35688
35689 arg3 = &temp3;
35690 arg4 = &temp4;
35691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35693 if (!SWIG_IsOK(res1)) {
35694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35695 }
35696 arg1 = reinterpret_cast< wxWindow * >(argp1);
35697 {
35698 arg2 = wxString_in_helper(obj1);
35699 if (arg2 == NULL) SWIG_fail;
35700 temp2 = true;
35701 }
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 resultobj = SWIG_Py_Void();
35709 if (SWIG_IsTmpObj(res3)) {
35710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35711 } else {
35712 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35714 }
35715 if (SWIG_IsTmpObj(res4)) {
35716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35717 } else {
35718 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35720 }
35721 {
35722 if (temp2)
35723 delete arg2;
35724 }
35725 return resultobj;
35726 fail:
35727 {
35728 if (temp2)
35729 delete arg2;
35730 }
35731 return NULL;
35732 }
35733
35734
35735 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35736 PyObject *resultobj = 0;
35737 wxWindow *arg1 = (wxWindow *) 0 ;
35738 wxString *arg2 = 0 ;
35739 int *arg3 = (int *) 0 ;
35740 int *arg4 = (int *) 0 ;
35741 int *arg5 = (int *) 0 ;
35742 int *arg6 = (int *) 0 ;
35743 wxFont *arg7 = (wxFont *) NULL ;
35744 void *argp1 = 0 ;
35745 int res1 = 0 ;
35746 bool temp2 = false ;
35747 int temp3 ;
35748 int res3 = SWIG_TMPOBJ ;
35749 int temp4 ;
35750 int res4 = SWIG_TMPOBJ ;
35751 int temp5 ;
35752 int res5 = SWIG_TMPOBJ ;
35753 int temp6 ;
35754 int res6 = SWIG_TMPOBJ ;
35755 void *argp7 = 0 ;
35756 int res7 = 0 ;
35757 PyObject * obj0 = 0 ;
35758 PyObject * obj1 = 0 ;
35759 PyObject * obj2 = 0 ;
35760 char * kwnames[] = {
35761 (char *) "self",(char *) "string",(char *) "font", NULL
35762 };
35763
35764 arg3 = &temp3;
35765 arg4 = &temp4;
35766 arg5 = &temp5;
35767 arg6 = &temp6;
35768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35770 if (!SWIG_IsOK(res1)) {
35771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35772 }
35773 arg1 = reinterpret_cast< wxWindow * >(argp1);
35774 {
35775 arg2 = wxString_in_helper(obj1);
35776 if (arg2 == NULL) SWIG_fail;
35777 temp2 = true;
35778 }
35779 if (obj2) {
35780 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35781 if (!SWIG_IsOK(res7)) {
35782 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35783 }
35784 arg7 = reinterpret_cast< wxFont * >(argp7);
35785 }
35786 {
35787 PyThreadState* __tstate = wxPyBeginAllowThreads();
35788 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35789 wxPyEndAllowThreads(__tstate);
35790 if (PyErr_Occurred()) SWIG_fail;
35791 }
35792 resultobj = SWIG_Py_Void();
35793 if (SWIG_IsTmpObj(res3)) {
35794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35795 } else {
35796 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35798 }
35799 if (SWIG_IsTmpObj(res4)) {
35800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35801 } else {
35802 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35803 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35804 }
35805 if (SWIG_IsTmpObj(res5)) {
35806 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35807 } else {
35808 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35810 }
35811 if (SWIG_IsTmpObj(res6)) {
35812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35813 } else {
35814 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35816 }
35817 {
35818 if (temp2)
35819 delete arg2;
35820 }
35821 return resultobj;
35822 fail:
35823 {
35824 if (temp2)
35825 delete arg2;
35826 }
35827 return NULL;
35828 }
35829
35830
35831 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj = 0;
35833 wxWindow *arg1 = (wxWindow *) 0 ;
35834 int *arg2 = (int *) 0 ;
35835 int *arg3 = (int *) 0 ;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838 int temp2 ;
35839 int res2 = 0 ;
35840 int temp3 ;
35841 int res3 = 0 ;
35842 PyObject * obj0 = 0 ;
35843 PyObject * obj1 = 0 ;
35844 PyObject * obj2 = 0 ;
35845 char * kwnames[] = {
35846 (char *) "self",(char *) "x",(char *) "y", NULL
35847 };
35848
35849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35851 if (!SWIG_IsOK(res1)) {
35852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35853 }
35854 arg1 = reinterpret_cast< wxWindow * >(argp1);
35855 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35856 int val;
35857 int ecode = SWIG_AsVal_int(obj1, &val);
35858 if (!SWIG_IsOK(ecode)) {
35859 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35860 }
35861 temp2 = static_cast< int >(val);
35862 arg2 = &temp2;
35863 res2 = SWIG_AddTmpMask(ecode);
35864 }
35865 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35866 int val;
35867 int ecode = SWIG_AsVal_int(obj2, &val);
35868 if (!SWIG_IsOK(ecode)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35870 }
35871 temp3 = static_cast< int >(val);
35872 arg3 = &temp3;
35873 res3 = SWIG_AddTmpMask(ecode);
35874 }
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 resultobj = SWIG_Py_Void();
35882 if (SWIG_IsTmpObj(res2)) {
35883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35884 } else {
35885 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35887 }
35888 if (SWIG_IsTmpObj(res3)) {
35889 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35890 } else {
35891 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35893 }
35894 return resultobj;
35895 fail:
35896 return NULL;
35897 }
35898
35899
35900 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj = 0;
35902 wxWindow *arg1 = (wxWindow *) 0 ;
35903 int *arg2 = (int *) 0 ;
35904 int *arg3 = (int *) 0 ;
35905 void *argp1 = 0 ;
35906 int res1 = 0 ;
35907 int temp2 ;
35908 int res2 = 0 ;
35909 int temp3 ;
35910 int res3 = 0 ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 PyObject * obj2 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "x",(char *) "y", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35925 int val;
35926 int ecode = SWIG_AsVal_int(obj1, &val);
35927 if (!SWIG_IsOK(ecode)) {
35928 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35929 }
35930 temp2 = static_cast< int >(val);
35931 arg2 = &temp2;
35932 res2 = SWIG_AddTmpMask(ecode);
35933 }
35934 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35935 int val;
35936 int ecode = SWIG_AsVal_int(obj2, &val);
35937 if (!SWIG_IsOK(ecode)) {
35938 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35939 }
35940 temp3 = static_cast< int >(val);
35941 arg3 = &temp3;
35942 res3 = SWIG_AddTmpMask(ecode);
35943 }
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_Py_Void();
35951 if (SWIG_IsTmpObj(res2)) {
35952 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35953 } else {
35954 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35955 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35956 }
35957 if (SWIG_IsTmpObj(res3)) {
35958 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35959 } else {
35960 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35962 }
35963 return resultobj;
35964 fail:
35965 return NULL;
35966 }
35967
35968
35969 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35970 PyObject *resultobj = 0;
35971 wxWindow *arg1 = (wxWindow *) 0 ;
35972 wxPoint *arg2 = 0 ;
35973 wxPoint result;
35974 void *argp1 = 0 ;
35975 int res1 = 0 ;
35976 wxPoint temp2 ;
35977 PyObject * obj0 = 0 ;
35978 PyObject * obj1 = 0 ;
35979 char * kwnames[] = {
35980 (char *) "self",(char *) "pt", NULL
35981 };
35982
35983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35985 if (!SWIG_IsOK(res1)) {
35986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35987 }
35988 arg1 = reinterpret_cast< wxWindow * >(argp1);
35989 {
35990 arg2 = &temp2;
35991 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35992 }
35993 {
35994 PyThreadState* __tstate = wxPyBeginAllowThreads();
35995 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35996 wxPyEndAllowThreads(__tstate);
35997 if (PyErr_Occurred()) SWIG_fail;
35998 }
35999 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36000 return resultobj;
36001 fail:
36002 return NULL;
36003 }
36004
36005
36006 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36007 PyObject *resultobj = 0;
36008 wxWindow *arg1 = (wxWindow *) 0 ;
36009 wxPoint *arg2 = 0 ;
36010 wxPoint result;
36011 void *argp1 = 0 ;
36012 int res1 = 0 ;
36013 wxPoint temp2 ;
36014 PyObject * obj0 = 0 ;
36015 PyObject * obj1 = 0 ;
36016 char * kwnames[] = {
36017 (char *) "self",(char *) "pt", NULL
36018 };
36019
36020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) 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_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 {
36027 arg2 = &temp2;
36028 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36029 }
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36044 PyObject *resultobj = 0;
36045 wxWindow *arg1 = (wxWindow *) 0 ;
36046 int arg2 ;
36047 int arg3 ;
36048 wxHitTest result;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 int val2 ;
36052 int ecode2 = 0 ;
36053 int val3 ;
36054 int ecode3 = 0 ;
36055 PyObject * obj0 = 0 ;
36056 PyObject * obj1 = 0 ;
36057 PyObject * obj2 = 0 ;
36058 char * kwnames[] = {
36059 (char *) "self",(char *) "x",(char *) "y", NULL
36060 };
36061
36062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36064 if (!SWIG_IsOK(res1)) {
36065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36066 }
36067 arg1 = reinterpret_cast< wxWindow * >(argp1);
36068 ecode2 = SWIG_AsVal_int(obj1, &val2);
36069 if (!SWIG_IsOK(ecode2)) {
36070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36071 }
36072 arg2 = static_cast< int >(val2);
36073 ecode3 = SWIG_AsVal_int(obj2, &val3);
36074 if (!SWIG_IsOK(ecode3)) {
36075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36076 }
36077 arg3 = static_cast< int >(val3);
36078 {
36079 PyThreadState* __tstate = wxPyBeginAllowThreads();
36080 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 resultobj = SWIG_From_int(static_cast< int >(result));
36085 return resultobj;
36086 fail:
36087 return NULL;
36088 }
36089
36090
36091 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36092 PyObject *resultobj = 0;
36093 wxWindow *arg1 = (wxWindow *) 0 ;
36094 wxPoint *arg2 = 0 ;
36095 wxHitTest result;
36096 void *argp1 = 0 ;
36097 int res1 = 0 ;
36098 wxPoint temp2 ;
36099 PyObject * obj0 = 0 ;
36100 PyObject * obj1 = 0 ;
36101 char * kwnames[] = {
36102 (char *) "self",(char *) "pt", NULL
36103 };
36104
36105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36107 if (!SWIG_IsOK(res1)) {
36108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36109 }
36110 arg1 = reinterpret_cast< wxWindow * >(argp1);
36111 {
36112 arg2 = &temp2;
36113 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36114 }
36115 {
36116 PyThreadState* __tstate = wxPyBeginAllowThreads();
36117 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36118 wxPyEndAllowThreads(__tstate);
36119 if (PyErr_Occurred()) SWIG_fail;
36120 }
36121 resultobj = SWIG_From_int(static_cast< int >(result));
36122 return resultobj;
36123 fail:
36124 return NULL;
36125 }
36126
36127
36128 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36129 PyObject *resultobj = 0;
36130 wxWindow *arg1 = (wxWindow *) 0 ;
36131 long arg2 ;
36132 wxBorder result;
36133 void *argp1 = 0 ;
36134 int res1 = 0 ;
36135 long val2 ;
36136 int ecode2 = 0 ;
36137
36138 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36140 if (!SWIG_IsOK(res1)) {
36141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36142 }
36143 arg1 = reinterpret_cast< wxWindow * >(argp1);
36144 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36145 if (!SWIG_IsOK(ecode2)) {
36146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36147 }
36148 arg2 = static_cast< long >(val2);
36149 {
36150 PyThreadState* __tstate = wxPyBeginAllowThreads();
36151 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36152 wxPyEndAllowThreads(__tstate);
36153 if (PyErr_Occurred()) SWIG_fail;
36154 }
36155 resultobj = SWIG_From_int(static_cast< int >(result));
36156 return resultobj;
36157 fail:
36158 return NULL;
36159 }
36160
36161
36162 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36163 PyObject *resultobj = 0;
36164 wxWindow *arg1 = (wxWindow *) 0 ;
36165 wxBorder result;
36166 void *argp1 = 0 ;
36167 int res1 = 0 ;
36168
36169 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36171 if (!SWIG_IsOK(res1)) {
36172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36173 }
36174 arg1 = reinterpret_cast< wxWindow * >(argp1);
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_From_int(static_cast< int >(result));
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36189 int argc;
36190 PyObject *argv[3];
36191
36192 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36193 --argc;
36194 if (argc == 1) {
36195 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36196 }
36197 if (argc == 2) {
36198 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36199 }
36200
36201 fail:
36202 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36203 return NULL;
36204 }
36205
36206
36207 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36208 PyObject *resultobj = 0;
36209 wxWindow *arg1 = (wxWindow *) 0 ;
36210 long arg2 = (long) wxUPDATE_UI_NONE ;
36211 void *argp1 = 0 ;
36212 int res1 = 0 ;
36213 long val2 ;
36214 int ecode2 = 0 ;
36215 PyObject * obj0 = 0 ;
36216 PyObject * obj1 = 0 ;
36217 char * kwnames[] = {
36218 (char *) "self",(char *) "flags", NULL
36219 };
36220
36221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36223 if (!SWIG_IsOK(res1)) {
36224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36225 }
36226 arg1 = reinterpret_cast< wxWindow * >(argp1);
36227 if (obj1) {
36228 ecode2 = SWIG_AsVal_long(obj1, &val2);
36229 if (!SWIG_IsOK(ecode2)) {
36230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36231 }
36232 arg2 = static_cast< long >(val2);
36233 }
36234 {
36235 PyThreadState* __tstate = wxPyBeginAllowThreads();
36236 (arg1)->UpdateWindowUI(arg2);
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 resultobj = SWIG_Py_Void();
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 wxMenu *arg2 = (wxMenu *) 0 ;
36251 int arg3 = (int) -1 ;
36252 int arg4 = (int) -1 ;
36253 bool result;
36254 void *argp1 = 0 ;
36255 int res1 = 0 ;
36256 void *argp2 = 0 ;
36257 int res2 = 0 ;
36258 int val3 ;
36259 int ecode3 = 0 ;
36260 int val4 ;
36261 int ecode4 = 0 ;
36262 PyObject * obj0 = 0 ;
36263 PyObject * obj1 = 0 ;
36264 PyObject * obj2 = 0 ;
36265 PyObject * obj3 = 0 ;
36266 char * kwnames[] = {
36267 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36268 };
36269
36270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36272 if (!SWIG_IsOK(res1)) {
36273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36274 }
36275 arg1 = reinterpret_cast< wxWindow * >(argp1);
36276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36277 if (!SWIG_IsOK(res2)) {
36278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36279 }
36280 arg2 = reinterpret_cast< wxMenu * >(argp2);
36281 if (obj2) {
36282 ecode3 = SWIG_AsVal_int(obj2, &val3);
36283 if (!SWIG_IsOK(ecode3)) {
36284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36285 }
36286 arg3 = static_cast< int >(val3);
36287 }
36288 if (obj3) {
36289 ecode4 = SWIG_AsVal_int(obj3, &val4);
36290 if (!SWIG_IsOK(ecode4)) {
36291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36292 }
36293 arg4 = static_cast< int >(val4);
36294 }
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36298 wxPyEndAllowThreads(__tstate);
36299 if (PyErr_Occurred()) SWIG_fail;
36300 }
36301 {
36302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36303 }
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36311 PyObject *resultobj = 0;
36312 wxWindow *arg1 = (wxWindow *) 0 ;
36313 wxMenu *arg2 = (wxMenu *) 0 ;
36314 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36315 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36316 bool result;
36317 void *argp1 = 0 ;
36318 int res1 = 0 ;
36319 void *argp2 = 0 ;
36320 int res2 = 0 ;
36321 wxPoint temp3 ;
36322 PyObject * obj0 = 0 ;
36323 PyObject * obj1 = 0 ;
36324 PyObject * obj2 = 0 ;
36325 char * kwnames[] = {
36326 (char *) "self",(char *) "menu",(char *) "pos", NULL
36327 };
36328
36329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36331 if (!SWIG_IsOK(res1)) {
36332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36333 }
36334 arg1 = reinterpret_cast< wxWindow * >(argp1);
36335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36336 if (!SWIG_IsOK(res2)) {
36337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36338 }
36339 arg2 = reinterpret_cast< wxMenu * >(argp2);
36340 if (obj2) {
36341 {
36342 arg3 = &temp3;
36343 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36344 }
36345 }
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxWindow *arg1 = (wxWindow *) 0 ;
36364 bool result;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36384 }
36385 return resultobj;
36386 fail:
36387 return NULL;
36388 }
36389
36390
36391 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36392 PyObject *resultobj = 0;
36393 wxWindow *arg1 = (wxWindow *) 0 ;
36394 long result;
36395 void *argp1 = 0 ;
36396 int res1 = 0 ;
36397 PyObject *swig_obj[1] ;
36398
36399 if (!args) SWIG_fail;
36400 swig_obj[0] = args;
36401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (long)wxWindow_GetHandle(arg1);
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 resultobj = SWIG_From_long(static_cast< long >(result));
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36420 PyObject *resultobj = 0;
36421 wxWindow *arg1 = (wxWindow *) 0 ;
36422 long arg2 ;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 long val2 ;
36426 int ecode2 = 0 ;
36427 PyObject * obj0 = 0 ;
36428 PyObject * obj1 = 0 ;
36429 char * kwnames[] = {
36430 (char *) "self",(char *) "handle", NULL
36431 };
36432
36433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36435 if (!SWIG_IsOK(res1)) {
36436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36437 }
36438 arg1 = reinterpret_cast< wxWindow * >(argp1);
36439 ecode2 = SWIG_AsVal_long(obj1, &val2);
36440 if (!SWIG_IsOK(ecode2)) {
36441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36442 }
36443 arg2 = static_cast< long >(val2);
36444 {
36445 PyThreadState* __tstate = wxPyBeginAllowThreads();
36446 wxWindow_AssociateHandle(arg1,arg2);
36447 wxPyEndAllowThreads(__tstate);
36448 if (PyErr_Occurred()) SWIG_fail;
36449 }
36450 resultobj = SWIG_Py_Void();
36451 return resultobj;
36452 fail:
36453 return NULL;
36454 }
36455
36456
36457 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36458 PyObject *resultobj = 0;
36459 wxWindow *arg1 = (wxWindow *) 0 ;
36460 void *argp1 = 0 ;
36461 int res1 = 0 ;
36462 PyObject *swig_obj[1] ;
36463
36464 if (!args) SWIG_fail;
36465 swig_obj[0] = args;
36466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36467 if (!SWIG_IsOK(res1)) {
36468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36469 }
36470 arg1 = reinterpret_cast< wxWindow * >(argp1);
36471 {
36472 PyThreadState* __tstate = wxPyBeginAllowThreads();
36473 (arg1)->DissociateHandle();
36474 wxPyEndAllowThreads(__tstate);
36475 if (PyErr_Occurred()) SWIG_fail;
36476 }
36477 resultobj = SWIG_Py_Void();
36478 return resultobj;
36479 fail:
36480 return NULL;
36481 }
36482
36483
36484 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36485 PyObject *resultobj = 0;
36486 wxWindow *arg1 = (wxWindow *) 0 ;
36487 int arg2 ;
36488 bool result;
36489 void *argp1 = 0 ;
36490 int res1 = 0 ;
36491 int val2 ;
36492 int ecode2 = 0 ;
36493 PyObject * obj0 = 0 ;
36494 PyObject * obj1 = 0 ;
36495 char * kwnames[] = {
36496 (char *) "self",(char *) "orient", NULL
36497 };
36498
36499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36503 }
36504 arg1 = reinterpret_cast< wxWindow * >(argp1);
36505 ecode2 = SWIG_AsVal_int(obj1, &val2);
36506 if (!SWIG_IsOK(ecode2)) {
36507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36508 }
36509 arg2 = static_cast< int >(val2);
36510 {
36511 PyThreadState* __tstate = wxPyBeginAllowThreads();
36512 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36513 wxPyEndAllowThreads(__tstate);
36514 if (PyErr_Occurred()) SWIG_fail;
36515 }
36516 {
36517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36518 }
36519 return resultobj;
36520 fail:
36521 return NULL;
36522 }
36523
36524
36525 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36526 PyObject *resultobj = 0;
36527 wxWindow *arg1 = (wxWindow *) 0 ;
36528 int arg2 ;
36529 int arg3 ;
36530 int arg4 ;
36531 int arg5 ;
36532 bool arg6 = (bool) true ;
36533 void *argp1 = 0 ;
36534 int res1 = 0 ;
36535 int val2 ;
36536 int ecode2 = 0 ;
36537 int val3 ;
36538 int ecode3 = 0 ;
36539 int val4 ;
36540 int ecode4 = 0 ;
36541 int val5 ;
36542 int ecode5 = 0 ;
36543 bool val6 ;
36544 int ecode6 = 0 ;
36545 PyObject * obj0 = 0 ;
36546 PyObject * obj1 = 0 ;
36547 PyObject * obj2 = 0 ;
36548 PyObject * obj3 = 0 ;
36549 PyObject * obj4 = 0 ;
36550 PyObject * obj5 = 0 ;
36551 char * kwnames[] = {
36552 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36553 };
36554
36555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36557 if (!SWIG_IsOK(res1)) {
36558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36559 }
36560 arg1 = reinterpret_cast< wxWindow * >(argp1);
36561 ecode2 = SWIG_AsVal_int(obj1, &val2);
36562 if (!SWIG_IsOK(ecode2)) {
36563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36564 }
36565 arg2 = static_cast< int >(val2);
36566 ecode3 = SWIG_AsVal_int(obj2, &val3);
36567 if (!SWIG_IsOK(ecode3)) {
36568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36569 }
36570 arg3 = static_cast< int >(val3);
36571 ecode4 = SWIG_AsVal_int(obj3, &val4);
36572 if (!SWIG_IsOK(ecode4)) {
36573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36574 }
36575 arg4 = static_cast< int >(val4);
36576 ecode5 = SWIG_AsVal_int(obj4, &val5);
36577 if (!SWIG_IsOK(ecode5)) {
36578 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36579 }
36580 arg5 = static_cast< int >(val5);
36581 if (obj5) {
36582 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36583 if (!SWIG_IsOK(ecode6)) {
36584 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36585 }
36586 arg6 = static_cast< bool >(val6);
36587 }
36588 {
36589 PyThreadState* __tstate = wxPyBeginAllowThreads();
36590 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 resultobj = SWIG_Py_Void();
36595 return resultobj;
36596 fail:
36597 return NULL;
36598 }
36599
36600
36601 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36602 PyObject *resultobj = 0;
36603 wxWindow *arg1 = (wxWindow *) 0 ;
36604 int arg2 ;
36605 int arg3 ;
36606 bool arg4 = (bool) true ;
36607 void *argp1 = 0 ;
36608 int res1 = 0 ;
36609 int val2 ;
36610 int ecode2 = 0 ;
36611 int val3 ;
36612 int ecode3 = 0 ;
36613 bool val4 ;
36614 int ecode4 = 0 ;
36615 PyObject * obj0 = 0 ;
36616 PyObject * obj1 = 0 ;
36617 PyObject * obj2 = 0 ;
36618 PyObject * obj3 = 0 ;
36619 char * kwnames[] = {
36620 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36621 };
36622
36623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36625 if (!SWIG_IsOK(res1)) {
36626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36627 }
36628 arg1 = reinterpret_cast< wxWindow * >(argp1);
36629 ecode2 = SWIG_AsVal_int(obj1, &val2);
36630 if (!SWIG_IsOK(ecode2)) {
36631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36632 }
36633 arg2 = static_cast< int >(val2);
36634 ecode3 = SWIG_AsVal_int(obj2, &val3);
36635 if (!SWIG_IsOK(ecode3)) {
36636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36637 }
36638 arg3 = static_cast< int >(val3);
36639 if (obj3) {
36640 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36641 if (!SWIG_IsOK(ecode4)) {
36642 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36643 }
36644 arg4 = static_cast< bool >(val4);
36645 }
36646 {
36647 PyThreadState* __tstate = wxPyBeginAllowThreads();
36648 (arg1)->SetScrollPos(arg2,arg3,arg4);
36649 wxPyEndAllowThreads(__tstate);
36650 if (PyErr_Occurred()) SWIG_fail;
36651 }
36652 resultobj = SWIG_Py_Void();
36653 return resultobj;
36654 fail:
36655 return NULL;
36656 }
36657
36658
36659 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36660 PyObject *resultobj = 0;
36661 wxWindow *arg1 = (wxWindow *) 0 ;
36662 int arg2 ;
36663 int result;
36664 void *argp1 = 0 ;
36665 int res1 = 0 ;
36666 int val2 ;
36667 int ecode2 = 0 ;
36668 PyObject * obj0 = 0 ;
36669 PyObject * obj1 = 0 ;
36670 char * kwnames[] = {
36671 (char *) "self",(char *) "orientation", NULL
36672 };
36673
36674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36676 if (!SWIG_IsOK(res1)) {
36677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36678 }
36679 arg1 = reinterpret_cast< wxWindow * >(argp1);
36680 ecode2 = SWIG_AsVal_int(obj1, &val2);
36681 if (!SWIG_IsOK(ecode2)) {
36682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36683 }
36684 arg2 = static_cast< int >(val2);
36685 {
36686 PyThreadState* __tstate = wxPyBeginAllowThreads();
36687 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36688 wxPyEndAllowThreads(__tstate);
36689 if (PyErr_Occurred()) SWIG_fail;
36690 }
36691 resultobj = SWIG_From_int(static_cast< int >(result));
36692 return resultobj;
36693 fail:
36694 return NULL;
36695 }
36696
36697
36698 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36699 PyObject *resultobj = 0;
36700 wxWindow *arg1 = (wxWindow *) 0 ;
36701 int arg2 ;
36702 int result;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 int val2 ;
36706 int ecode2 = 0 ;
36707 PyObject * obj0 = 0 ;
36708 PyObject * obj1 = 0 ;
36709 char * kwnames[] = {
36710 (char *) "self",(char *) "orientation", NULL
36711 };
36712
36713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36715 if (!SWIG_IsOK(res1)) {
36716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36717 }
36718 arg1 = reinterpret_cast< wxWindow * >(argp1);
36719 ecode2 = SWIG_AsVal_int(obj1, &val2);
36720 if (!SWIG_IsOK(ecode2)) {
36721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36722 }
36723 arg2 = static_cast< int >(val2);
36724 {
36725 PyThreadState* __tstate = wxPyBeginAllowThreads();
36726 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36727 wxPyEndAllowThreads(__tstate);
36728 if (PyErr_Occurred()) SWIG_fail;
36729 }
36730 resultobj = SWIG_From_int(static_cast< int >(result));
36731 return resultobj;
36732 fail:
36733 return NULL;
36734 }
36735
36736
36737 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36738 PyObject *resultobj = 0;
36739 wxWindow *arg1 = (wxWindow *) 0 ;
36740 int arg2 ;
36741 int result;
36742 void *argp1 = 0 ;
36743 int res1 = 0 ;
36744 int val2 ;
36745 int ecode2 = 0 ;
36746 PyObject * obj0 = 0 ;
36747 PyObject * obj1 = 0 ;
36748 char * kwnames[] = {
36749 (char *) "self",(char *) "orientation", NULL
36750 };
36751
36752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36754 if (!SWIG_IsOK(res1)) {
36755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36756 }
36757 arg1 = reinterpret_cast< wxWindow * >(argp1);
36758 ecode2 = SWIG_AsVal_int(obj1, &val2);
36759 if (!SWIG_IsOK(ecode2)) {
36760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36761 }
36762 arg2 = static_cast< int >(val2);
36763 {
36764 PyThreadState* __tstate = wxPyBeginAllowThreads();
36765 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36766 wxPyEndAllowThreads(__tstate);
36767 if (PyErr_Occurred()) SWIG_fail;
36768 }
36769 resultobj = SWIG_From_int(static_cast< int >(result));
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36777 PyObject *resultobj = 0;
36778 wxWindow *arg1 = (wxWindow *) 0 ;
36779 int arg2 ;
36780 int arg3 ;
36781 wxRect *arg4 = (wxRect *) NULL ;
36782 void *argp1 = 0 ;
36783 int res1 = 0 ;
36784 int val2 ;
36785 int ecode2 = 0 ;
36786 int val3 ;
36787 int ecode3 = 0 ;
36788 void *argp4 = 0 ;
36789 int res4 = 0 ;
36790 PyObject * obj0 = 0 ;
36791 PyObject * obj1 = 0 ;
36792 PyObject * obj2 = 0 ;
36793 PyObject * obj3 = 0 ;
36794 char * kwnames[] = {
36795 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36796 };
36797
36798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36800 if (!SWIG_IsOK(res1)) {
36801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36802 }
36803 arg1 = reinterpret_cast< wxWindow * >(argp1);
36804 ecode2 = SWIG_AsVal_int(obj1, &val2);
36805 if (!SWIG_IsOK(ecode2)) {
36806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36807 }
36808 arg2 = static_cast< int >(val2);
36809 ecode3 = SWIG_AsVal_int(obj2, &val3);
36810 if (!SWIG_IsOK(ecode3)) {
36811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36812 }
36813 arg3 = static_cast< int >(val3);
36814 if (obj3) {
36815 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36816 if (!SWIG_IsOK(res4)) {
36817 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36818 }
36819 arg4 = reinterpret_cast< wxRect * >(argp4);
36820 }
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 resultobj = SWIG_Py_Void();
36828 return resultobj;
36829 fail:
36830 return NULL;
36831 }
36832
36833
36834 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36835 PyObject *resultobj = 0;
36836 wxWindow *arg1 = (wxWindow *) 0 ;
36837 int arg2 ;
36838 bool result;
36839 void *argp1 = 0 ;
36840 int res1 = 0 ;
36841 int val2 ;
36842 int ecode2 = 0 ;
36843 PyObject * obj0 = 0 ;
36844 PyObject * obj1 = 0 ;
36845 char * kwnames[] = {
36846 (char *) "self",(char *) "lines", NULL
36847 };
36848
36849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36851 if (!SWIG_IsOK(res1)) {
36852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36853 }
36854 arg1 = reinterpret_cast< wxWindow * >(argp1);
36855 ecode2 = SWIG_AsVal_int(obj1, &val2);
36856 if (!SWIG_IsOK(ecode2)) {
36857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36858 }
36859 arg2 = static_cast< int >(val2);
36860 {
36861 PyThreadState* __tstate = wxPyBeginAllowThreads();
36862 result = (bool)(arg1)->ScrollLines(arg2);
36863 wxPyEndAllowThreads(__tstate);
36864 if (PyErr_Occurred()) SWIG_fail;
36865 }
36866 {
36867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36868 }
36869 return resultobj;
36870 fail:
36871 return NULL;
36872 }
36873
36874
36875 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36876 PyObject *resultobj = 0;
36877 wxWindow *arg1 = (wxWindow *) 0 ;
36878 int arg2 ;
36879 bool result;
36880 void *argp1 = 0 ;
36881 int res1 = 0 ;
36882 int val2 ;
36883 int ecode2 = 0 ;
36884 PyObject * obj0 = 0 ;
36885 PyObject * obj1 = 0 ;
36886 char * kwnames[] = {
36887 (char *) "self",(char *) "pages", NULL
36888 };
36889
36890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 ecode2 = SWIG_AsVal_int(obj1, &val2);
36897 if (!SWIG_IsOK(ecode2)) {
36898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36899 }
36900 arg2 = static_cast< int >(val2);
36901 {
36902 PyThreadState* __tstate = wxPyBeginAllowThreads();
36903 result = (bool)(arg1)->ScrollPages(arg2);
36904 wxPyEndAllowThreads(__tstate);
36905 if (PyErr_Occurred()) SWIG_fail;
36906 }
36907 {
36908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36909 }
36910 return resultobj;
36911 fail:
36912 return NULL;
36913 }
36914
36915
36916 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36917 PyObject *resultobj = 0;
36918 wxWindow *arg1 = (wxWindow *) 0 ;
36919 bool result;
36920 void *argp1 = 0 ;
36921 int res1 = 0 ;
36922 PyObject *swig_obj[1] ;
36923
36924 if (!args) SWIG_fail;
36925 swig_obj[0] = args;
36926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36927 if (!SWIG_IsOK(res1)) {
36928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36929 }
36930 arg1 = reinterpret_cast< wxWindow * >(argp1);
36931 {
36932 PyThreadState* __tstate = wxPyBeginAllowThreads();
36933 result = (bool)(arg1)->LineUp();
36934 wxPyEndAllowThreads(__tstate);
36935 if (PyErr_Occurred()) SWIG_fail;
36936 }
36937 {
36938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36939 }
36940 return resultobj;
36941 fail:
36942 return NULL;
36943 }
36944
36945
36946 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36947 PyObject *resultobj = 0;
36948 wxWindow *arg1 = (wxWindow *) 0 ;
36949 bool result;
36950 void *argp1 = 0 ;
36951 int res1 = 0 ;
36952 PyObject *swig_obj[1] ;
36953
36954 if (!args) SWIG_fail;
36955 swig_obj[0] = args;
36956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36957 if (!SWIG_IsOK(res1)) {
36958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36959 }
36960 arg1 = reinterpret_cast< wxWindow * >(argp1);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = (bool)(arg1)->LineDown();
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 {
36968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36969 }
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 bool result;
36980 void *argp1 = 0 ;
36981 int res1 = 0 ;
36982 PyObject *swig_obj[1] ;
36983
36984 if (!args) SWIG_fail;
36985 swig_obj[0] = args;
36986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36987 if (!SWIG_IsOK(res1)) {
36988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36989 }
36990 arg1 = reinterpret_cast< wxWindow * >(argp1);
36991 {
36992 PyThreadState* __tstate = wxPyBeginAllowThreads();
36993 result = (bool)(arg1)->PageUp();
36994 wxPyEndAllowThreads(__tstate);
36995 if (PyErr_Occurred()) SWIG_fail;
36996 }
36997 {
36998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36999 }
37000 return resultobj;
37001 fail:
37002 return NULL;
37003 }
37004
37005
37006 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37007 PyObject *resultobj = 0;
37008 wxWindow *arg1 = (wxWindow *) 0 ;
37009 bool result;
37010 void *argp1 = 0 ;
37011 int res1 = 0 ;
37012 PyObject *swig_obj[1] ;
37013
37014 if (!args) SWIG_fail;
37015 swig_obj[0] = args;
37016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37017 if (!SWIG_IsOK(res1)) {
37018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37019 }
37020 arg1 = reinterpret_cast< wxWindow * >(argp1);
37021 {
37022 PyThreadState* __tstate = wxPyBeginAllowThreads();
37023 result = (bool)(arg1)->PageDown();
37024 wxPyEndAllowThreads(__tstate);
37025 if (PyErr_Occurred()) SWIG_fail;
37026 }
37027 {
37028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37029 }
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37037 PyObject *resultobj = 0;
37038 wxWindow *arg1 = (wxWindow *) 0 ;
37039 wxString *arg2 = 0 ;
37040 void *argp1 = 0 ;
37041 int res1 = 0 ;
37042 bool temp2 = false ;
37043 PyObject * obj0 = 0 ;
37044 PyObject * obj1 = 0 ;
37045 char * kwnames[] = {
37046 (char *) "self",(char *) "text", NULL
37047 };
37048
37049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 {
37056 arg2 = wxString_in_helper(obj1);
37057 if (arg2 == NULL) SWIG_fail;
37058 temp2 = true;
37059 }
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 (arg1)->SetHelpText((wxString const &)*arg2);
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 resultobj = SWIG_Py_Void();
37067 {
37068 if (temp2)
37069 delete arg2;
37070 }
37071 return resultobj;
37072 fail:
37073 {
37074 if (temp2)
37075 delete arg2;
37076 }
37077 return NULL;
37078 }
37079
37080
37081 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37082 PyObject *resultobj = 0;
37083 wxWindow *arg1 = (wxWindow *) 0 ;
37084 wxString *arg2 = 0 ;
37085 void *argp1 = 0 ;
37086 int res1 = 0 ;
37087 bool temp2 = false ;
37088 PyObject * obj0 = 0 ;
37089 PyObject * obj1 = 0 ;
37090 char * kwnames[] = {
37091 (char *) "self",(char *) "text", NULL
37092 };
37093
37094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37096 if (!SWIG_IsOK(res1)) {
37097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37098 }
37099 arg1 = reinterpret_cast< wxWindow * >(argp1);
37100 {
37101 arg2 = wxString_in_helper(obj1);
37102 if (arg2 == NULL) SWIG_fail;
37103 temp2 = true;
37104 }
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 resultobj = SWIG_Py_Void();
37112 {
37113 if (temp2)
37114 delete arg2;
37115 }
37116 return resultobj;
37117 fail:
37118 {
37119 if (temp2)
37120 delete arg2;
37121 }
37122 return NULL;
37123 }
37124
37125
37126 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37127 PyObject *resultobj = 0;
37128 wxWindow *arg1 = (wxWindow *) 0 ;
37129 wxPoint *arg2 = 0 ;
37130 wxHelpEvent::Origin arg3 ;
37131 wxString result;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 wxPoint temp2 ;
37135 void *argp3 ;
37136 int res3 = 0 ;
37137 PyObject * obj0 = 0 ;
37138 PyObject * obj1 = 0 ;
37139 PyObject * obj2 = 0 ;
37140 char * kwnames[] = {
37141 (char *) "self",(char *) "pt",(char *) "origin", NULL
37142 };
37143
37144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37146 if (!SWIG_IsOK(res1)) {
37147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37148 }
37149 arg1 = reinterpret_cast< wxWindow * >(argp1);
37150 {
37151 arg2 = &temp2;
37152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37153 }
37154 {
37155 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37156 if (!SWIG_IsOK(res3)) {
37157 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37158 }
37159 if (!argp3) {
37160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37161 } else {
37162 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37163 arg3 = *temp;
37164 if (SWIG_IsNewObj(res3)) delete temp;
37165 }
37166 }
37167 {
37168 PyThreadState* __tstate = wxPyBeginAllowThreads();
37169 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37170 wxPyEndAllowThreads(__tstate);
37171 if (PyErr_Occurred()) SWIG_fail;
37172 }
37173 {
37174 #if wxUSE_UNICODE
37175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37176 #else
37177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37178 #endif
37179 }
37180 return resultobj;
37181 fail:
37182 return NULL;
37183 }
37184
37185
37186 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37187 PyObject *resultobj = 0;
37188 wxWindow *arg1 = (wxWindow *) 0 ;
37189 wxString result;
37190 void *argp1 = 0 ;
37191 int res1 = 0 ;
37192 PyObject *swig_obj[1] ;
37193
37194 if (!args) SWIG_fail;
37195 swig_obj[0] = args;
37196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37197 if (!SWIG_IsOK(res1)) {
37198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37199 }
37200 arg1 = reinterpret_cast< wxWindow * >(argp1);
37201 {
37202 PyThreadState* __tstate = wxPyBeginAllowThreads();
37203 result = ((wxWindow const *)arg1)->GetHelpText();
37204 wxPyEndAllowThreads(__tstate);
37205 if (PyErr_Occurred()) SWIG_fail;
37206 }
37207 {
37208 #if wxUSE_UNICODE
37209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37210 #else
37211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37212 #endif
37213 }
37214 return resultobj;
37215 fail:
37216 return NULL;
37217 }
37218
37219
37220 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37221 PyObject *resultobj = 0;
37222 wxWindow *arg1 = (wxWindow *) 0 ;
37223 wxString *arg2 = 0 ;
37224 void *argp1 = 0 ;
37225 int res1 = 0 ;
37226 bool temp2 = false ;
37227 PyObject * obj0 = 0 ;
37228 PyObject * obj1 = 0 ;
37229 char * kwnames[] = {
37230 (char *) "self",(char *) "tip", NULL
37231 };
37232
37233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37235 if (!SWIG_IsOK(res1)) {
37236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37237 }
37238 arg1 = reinterpret_cast< wxWindow * >(argp1);
37239 {
37240 arg2 = wxString_in_helper(obj1);
37241 if (arg2 == NULL) SWIG_fail;
37242 temp2 = true;
37243 }
37244 {
37245 PyThreadState* __tstate = wxPyBeginAllowThreads();
37246 (arg1)->SetToolTip((wxString const &)*arg2);
37247 wxPyEndAllowThreads(__tstate);
37248 if (PyErr_Occurred()) SWIG_fail;
37249 }
37250 resultobj = SWIG_Py_Void();
37251 {
37252 if (temp2)
37253 delete arg2;
37254 }
37255 return resultobj;
37256 fail:
37257 {
37258 if (temp2)
37259 delete arg2;
37260 }
37261 return NULL;
37262 }
37263
37264
37265 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37266 PyObject *resultobj = 0;
37267 wxWindow *arg1 = (wxWindow *) 0 ;
37268 wxToolTip *arg2 = (wxToolTip *) 0 ;
37269 void *argp1 = 0 ;
37270 int res1 = 0 ;
37271 int res2 = 0 ;
37272 PyObject * obj0 = 0 ;
37273 PyObject * obj1 = 0 ;
37274 char * kwnames[] = {
37275 (char *) "self",(char *) "tip", NULL
37276 };
37277
37278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37280 if (!SWIG_IsOK(res1)) {
37281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37282 }
37283 arg1 = reinterpret_cast< wxWindow * >(argp1);
37284 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37285 if (!SWIG_IsOK(res2)) {
37286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37287 }
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 (arg1)->SetToolTip(arg2);
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 resultobj = SWIG_Py_Void();
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 wxToolTip *result = 0 ;
37305 void *argp1 = 0 ;
37306 int res1 = 0 ;
37307 PyObject *swig_obj[1] ;
37308
37309 if (!args) SWIG_fail;
37310 swig_obj[0] = args;
37311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37312 if (!SWIG_IsOK(res1)) {
37313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37314 }
37315 arg1 = reinterpret_cast< wxWindow * >(argp1);
37316 {
37317 PyThreadState* __tstate = wxPyBeginAllowThreads();
37318 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37319 wxPyEndAllowThreads(__tstate);
37320 if (PyErr_Occurred()) SWIG_fail;
37321 }
37322 {
37323 resultobj = wxPyMake_wxObject(result, (bool)0);
37324 }
37325 return resultobj;
37326 fail:
37327 return NULL;
37328 }
37329
37330
37331 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37332 PyObject *resultobj = 0;
37333 wxWindow *arg1 = (wxWindow *) 0 ;
37334 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37335 void *argp1 = 0 ;
37336 int res1 = 0 ;
37337 int res2 = 0 ;
37338 PyObject * obj0 = 0 ;
37339 PyObject * obj1 = 0 ;
37340 char * kwnames[] = {
37341 (char *) "self",(char *) "dropTarget", NULL
37342 };
37343
37344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37346 if (!SWIG_IsOK(res1)) {
37347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37348 }
37349 arg1 = reinterpret_cast< wxWindow * >(argp1);
37350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37351 if (!SWIG_IsOK(res2)) {
37352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37353 }
37354 {
37355 PyThreadState* __tstate = wxPyBeginAllowThreads();
37356 (arg1)->SetDropTarget(arg2);
37357 wxPyEndAllowThreads(__tstate);
37358 if (PyErr_Occurred()) SWIG_fail;
37359 }
37360 resultobj = SWIG_Py_Void();
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 wxPyDropTarget *result = 0 ;
37371 void *argp1 = 0 ;
37372 int res1 = 0 ;
37373 PyObject *swig_obj[1] ;
37374
37375 if (!args) SWIG_fail;
37376 swig_obj[0] = args;
37377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37378 if (!SWIG_IsOK(res1)) {
37379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37380 }
37381 arg1 = reinterpret_cast< wxWindow * >(argp1);
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj = 0;
37397 wxWindow *arg1 = (wxWindow *) 0 ;
37398 bool arg2 ;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 bool val2 ;
37402 int ecode2 = 0 ;
37403 PyObject * obj0 = 0 ;
37404 PyObject * obj1 = 0 ;
37405 char * kwnames[] = {
37406 (char *) "self",(char *) "accept", NULL
37407 };
37408
37409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37411 if (!SWIG_IsOK(res1)) {
37412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37413 }
37414 arg1 = reinterpret_cast< wxWindow * >(argp1);
37415 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37416 if (!SWIG_IsOK(ecode2)) {
37417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37418 }
37419 arg2 = static_cast< bool >(val2);
37420 {
37421 PyThreadState* __tstate = wxPyBeginAllowThreads();
37422 wxWindow_DragAcceptFiles(arg1,arg2);
37423 wxPyEndAllowThreads(__tstate);
37424 if (PyErr_Occurred()) SWIG_fail;
37425 }
37426 resultobj = SWIG_Py_Void();
37427 return resultobj;
37428 fail:
37429 return NULL;
37430 }
37431
37432
37433 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37434 PyObject *resultobj = 0;
37435 wxWindow *arg1 = (wxWindow *) 0 ;
37436 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 int res2 = 0 ;
37440 PyObject * obj0 = 0 ;
37441 PyObject * obj1 = 0 ;
37442 char * kwnames[] = {
37443 (char *) "self",(char *) "constraints", NULL
37444 };
37445
37446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37448 if (!SWIG_IsOK(res1)) {
37449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37450 }
37451 arg1 = reinterpret_cast< wxWindow * >(argp1);
37452 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37453 if (!SWIG_IsOK(res2)) {
37454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37455 }
37456 {
37457 PyThreadState* __tstate = wxPyBeginAllowThreads();
37458 (arg1)->SetConstraints(arg2);
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 resultobj = SWIG_Py_Void();
37463 return resultobj;
37464 fail:
37465 return NULL;
37466 }
37467
37468
37469 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37470 PyObject *resultobj = 0;
37471 wxWindow *arg1 = (wxWindow *) 0 ;
37472 wxLayoutConstraints *result = 0 ;
37473 void *argp1 = 0 ;
37474 int res1 = 0 ;
37475 PyObject *swig_obj[1] ;
37476
37477 if (!args) SWIG_fail;
37478 swig_obj[0] = args;
37479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37480 if (!SWIG_IsOK(res1)) {
37481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37482 }
37483 arg1 = reinterpret_cast< wxWindow * >(argp1);
37484 {
37485 PyThreadState* __tstate = wxPyBeginAllowThreads();
37486 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37487 wxPyEndAllowThreads(__tstate);
37488 if (PyErr_Occurred()) SWIG_fail;
37489 }
37490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37491 return resultobj;
37492 fail:
37493 return NULL;
37494 }
37495
37496
37497 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37498 PyObject *resultobj = 0;
37499 wxWindow *arg1 = (wxWindow *) 0 ;
37500 bool arg2 ;
37501 void *argp1 = 0 ;
37502 int res1 = 0 ;
37503 bool val2 ;
37504 int ecode2 = 0 ;
37505 PyObject * obj0 = 0 ;
37506 PyObject * obj1 = 0 ;
37507 char * kwnames[] = {
37508 (char *) "self",(char *) "autoLayout", NULL
37509 };
37510
37511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37513 if (!SWIG_IsOK(res1)) {
37514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37515 }
37516 arg1 = reinterpret_cast< wxWindow * >(argp1);
37517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37518 if (!SWIG_IsOK(ecode2)) {
37519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37520 }
37521 arg2 = static_cast< bool >(val2);
37522 {
37523 PyThreadState* __tstate = wxPyBeginAllowThreads();
37524 (arg1)->SetAutoLayout(arg2);
37525 wxPyEndAllowThreads(__tstate);
37526 if (PyErr_Occurred()) SWIG_fail;
37527 }
37528 resultobj = SWIG_Py_Void();
37529 return resultobj;
37530 fail:
37531 return NULL;
37532 }
37533
37534
37535 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37536 PyObject *resultobj = 0;
37537 wxWindow *arg1 = (wxWindow *) 0 ;
37538 bool result;
37539 void *argp1 = 0 ;
37540 int res1 = 0 ;
37541 PyObject *swig_obj[1] ;
37542
37543 if (!args) SWIG_fail;
37544 swig_obj[0] = args;
37545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37546 if (!SWIG_IsOK(res1)) {
37547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37548 }
37549 arg1 = reinterpret_cast< wxWindow * >(argp1);
37550 {
37551 PyThreadState* __tstate = wxPyBeginAllowThreads();
37552 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37553 wxPyEndAllowThreads(__tstate);
37554 if (PyErr_Occurred()) SWIG_fail;
37555 }
37556 {
37557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37558 }
37559 return resultobj;
37560 fail:
37561 return NULL;
37562 }
37563
37564
37565 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37566 PyObject *resultobj = 0;
37567 wxWindow *arg1 = (wxWindow *) 0 ;
37568 bool result;
37569 void *argp1 = 0 ;
37570 int res1 = 0 ;
37571 PyObject *swig_obj[1] ;
37572
37573 if (!args) SWIG_fail;
37574 swig_obj[0] = args;
37575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37576 if (!SWIG_IsOK(res1)) {
37577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37578 }
37579 arg1 = reinterpret_cast< wxWindow * >(argp1);
37580 {
37581 PyThreadState* __tstate = wxPyBeginAllowThreads();
37582 result = (bool)(arg1)->Layout();
37583 wxPyEndAllowThreads(__tstate);
37584 if (PyErr_Occurred()) SWIG_fail;
37585 }
37586 {
37587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37588 }
37589 return resultobj;
37590 fail:
37591 return NULL;
37592 }
37593
37594
37595 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37596 PyObject *resultobj = 0;
37597 wxWindow *arg1 = (wxWindow *) 0 ;
37598 wxSizer *arg2 = (wxSizer *) 0 ;
37599 bool arg3 = (bool) true ;
37600 void *argp1 = 0 ;
37601 int res1 = 0 ;
37602 int res2 = 0 ;
37603 bool val3 ;
37604 int ecode3 = 0 ;
37605 PyObject * obj0 = 0 ;
37606 PyObject * obj1 = 0 ;
37607 PyObject * obj2 = 0 ;
37608 char * kwnames[] = {
37609 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37610 };
37611
37612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37614 if (!SWIG_IsOK(res1)) {
37615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37616 }
37617 arg1 = reinterpret_cast< wxWindow * >(argp1);
37618 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37619 if (!SWIG_IsOK(res2)) {
37620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37621 }
37622 if (obj2) {
37623 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37624 if (!SWIG_IsOK(ecode3)) {
37625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37626 }
37627 arg3 = static_cast< bool >(val3);
37628 }
37629 {
37630 PyThreadState* __tstate = wxPyBeginAllowThreads();
37631 (arg1)->SetSizer(arg2,arg3);
37632 wxPyEndAllowThreads(__tstate);
37633 if (PyErr_Occurred()) SWIG_fail;
37634 }
37635 resultobj = SWIG_Py_Void();
37636 return resultobj;
37637 fail:
37638 return NULL;
37639 }
37640
37641
37642 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37643 PyObject *resultobj = 0;
37644 wxWindow *arg1 = (wxWindow *) 0 ;
37645 wxSizer *arg2 = (wxSizer *) 0 ;
37646 bool arg3 = (bool) true ;
37647 void *argp1 = 0 ;
37648 int res1 = 0 ;
37649 int res2 = 0 ;
37650 bool val3 ;
37651 int ecode3 = 0 ;
37652 PyObject * obj0 = 0 ;
37653 PyObject * obj1 = 0 ;
37654 PyObject * obj2 = 0 ;
37655 char * kwnames[] = {
37656 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37657 };
37658
37659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37661 if (!SWIG_IsOK(res1)) {
37662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37663 }
37664 arg1 = reinterpret_cast< wxWindow * >(argp1);
37665 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37666 if (!SWIG_IsOK(res2)) {
37667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37668 }
37669 if (obj2) {
37670 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37671 if (!SWIG_IsOK(ecode3)) {
37672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37673 }
37674 arg3 = static_cast< bool >(val3);
37675 }
37676 {
37677 PyThreadState* __tstate = wxPyBeginAllowThreads();
37678 (arg1)->SetSizerAndFit(arg2,arg3);
37679 wxPyEndAllowThreads(__tstate);
37680 if (PyErr_Occurred()) SWIG_fail;
37681 }
37682 resultobj = SWIG_Py_Void();
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37690 PyObject *resultobj = 0;
37691 wxWindow *arg1 = (wxWindow *) 0 ;
37692 wxSizer *result = 0 ;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 PyObject *swig_obj[1] ;
37696
37697 if (!args) SWIG_fail;
37698 swig_obj[0] = args;
37699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37700 if (!SWIG_IsOK(res1)) {
37701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37702 }
37703 arg1 = reinterpret_cast< wxWindow * >(argp1);
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = wxPyMake_wxObject(result, (bool)0);
37712 }
37713 return resultobj;
37714 fail:
37715 return NULL;
37716 }
37717
37718
37719 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37720 PyObject *resultobj = 0;
37721 wxWindow *arg1 = (wxWindow *) 0 ;
37722 wxSizer *arg2 = (wxSizer *) 0 ;
37723 void *argp1 = 0 ;
37724 int res1 = 0 ;
37725 void *argp2 = 0 ;
37726 int res2 = 0 ;
37727 PyObject * obj0 = 0 ;
37728 PyObject * obj1 = 0 ;
37729 char * kwnames[] = {
37730 (char *) "self",(char *) "sizer", NULL
37731 };
37732
37733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37735 if (!SWIG_IsOK(res1)) {
37736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37737 }
37738 arg1 = reinterpret_cast< wxWindow * >(argp1);
37739 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37740 if (!SWIG_IsOK(res2)) {
37741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37742 }
37743 arg2 = reinterpret_cast< wxSizer * >(argp2);
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 (arg1)->SetContainingSizer(arg2);
37747 wxPyEndAllowThreads(__tstate);
37748 if (PyErr_Occurred()) SWIG_fail;
37749 }
37750 resultobj = SWIG_Py_Void();
37751 return resultobj;
37752 fail:
37753 return NULL;
37754 }
37755
37756
37757 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37758 PyObject *resultobj = 0;
37759 wxWindow *arg1 = (wxWindow *) 0 ;
37760 wxSizer *result = 0 ;
37761 void *argp1 = 0 ;
37762 int res1 = 0 ;
37763 PyObject *swig_obj[1] ;
37764
37765 if (!args) SWIG_fail;
37766 swig_obj[0] = args;
37767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res1)) {
37769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37770 }
37771 arg1 = reinterpret_cast< wxWindow * >(argp1);
37772 {
37773 PyThreadState* __tstate = wxPyBeginAllowThreads();
37774 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37775 wxPyEndAllowThreads(__tstate);
37776 if (PyErr_Occurred()) SWIG_fail;
37777 }
37778 {
37779 resultobj = wxPyMake_wxObject(result, (bool)0);
37780 }
37781 return resultobj;
37782 fail:
37783 return NULL;
37784 }
37785
37786
37787 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37788 PyObject *resultobj = 0;
37789 wxWindow *arg1 = (wxWindow *) 0 ;
37790 void *argp1 = 0 ;
37791 int res1 = 0 ;
37792 PyObject *swig_obj[1] ;
37793
37794 if (!args) SWIG_fail;
37795 swig_obj[0] = args;
37796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37799 }
37800 arg1 = reinterpret_cast< wxWindow * >(argp1);
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 (arg1)->InheritAttributes();
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 resultobj = SWIG_Py_Void();
37808 return resultobj;
37809 fail:
37810 return NULL;
37811 }
37812
37813
37814 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37815 PyObject *resultobj = 0;
37816 wxWindow *arg1 = (wxWindow *) 0 ;
37817 bool result;
37818 void *argp1 = 0 ;
37819 int res1 = 0 ;
37820 PyObject *swig_obj[1] ;
37821
37822 if (!args) SWIG_fail;
37823 swig_obj[0] = args;
37824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37825 if (!SWIG_IsOK(res1)) {
37826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37827 }
37828 arg1 = reinterpret_cast< wxWindow * >(argp1);
37829 {
37830 PyThreadState* __tstate = wxPyBeginAllowThreads();
37831 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37832 wxPyEndAllowThreads(__tstate);
37833 if (PyErr_Occurred()) SWIG_fail;
37834 }
37835 {
37836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37837 }
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37845 PyObject *resultobj = 0;
37846 wxWindow *arg1 = (wxWindow *) 0 ;
37847 bool result;
37848 void *argp1 = 0 ;
37849 int res1 = 0 ;
37850 PyObject *swig_obj[1] ;
37851
37852 if (!args) SWIG_fail;
37853 swig_obj[0] = args;
37854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37855 if (!SWIG_IsOK(res1)) {
37856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37857 }
37858 arg1 = reinterpret_cast< wxWindow * >(argp1);
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 result = (bool)(arg1)->CanSetTransparent();
37862 wxPyEndAllowThreads(__tstate);
37863 if (PyErr_Occurred()) SWIG_fail;
37864 }
37865 {
37866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37867 }
37868 return resultobj;
37869 fail:
37870 return NULL;
37871 }
37872
37873
37874 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37875 PyObject *resultobj = 0;
37876 wxWindow *arg1 = (wxWindow *) 0 ;
37877 byte arg2 ;
37878 bool result;
37879 void *argp1 = 0 ;
37880 int res1 = 0 ;
37881 unsigned char val2 ;
37882 int ecode2 = 0 ;
37883 PyObject * obj0 = 0 ;
37884 PyObject * obj1 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "self",(char *) "alpha", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37893 }
37894 arg1 = reinterpret_cast< wxWindow * >(argp1);
37895 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37896 if (!SWIG_IsOK(ecode2)) {
37897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37898 }
37899 arg2 = static_cast< byte >(val2);
37900 {
37901 PyThreadState* __tstate = wxPyBeginAllowThreads();
37902 result = (bool)(arg1)->SetTransparent(arg2);
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 {
37907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37908 }
37909 return resultobj;
37910 fail:
37911 return NULL;
37912 }
37913
37914
37915 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 PyObject *obj;
37917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37918 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37919 return SWIG_Py_Void();
37920 }
37921
37922 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37923 return SWIG_Python_InitShadowInstance(args);
37924 }
37925
37926 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37927 PyObject *resultobj = 0;
37928 long arg1 ;
37929 wxWindow *arg2 = (wxWindow *) NULL ;
37930 wxWindow *result = 0 ;
37931 long val1 ;
37932 int ecode1 = 0 ;
37933 void *argp2 = 0 ;
37934 int res2 = 0 ;
37935 PyObject * obj0 = 0 ;
37936 PyObject * obj1 = 0 ;
37937 char * kwnames[] = {
37938 (char *) "id",(char *) "parent", NULL
37939 };
37940
37941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37942 ecode1 = SWIG_AsVal_long(obj0, &val1);
37943 if (!SWIG_IsOK(ecode1)) {
37944 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37945 }
37946 arg1 = static_cast< long >(val1);
37947 if (obj1) {
37948 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37949 if (!SWIG_IsOK(res2)) {
37950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37951 }
37952 arg2 = reinterpret_cast< wxWindow * >(argp2);
37953 }
37954 {
37955 if (!wxPyCheckForApp()) SWIG_fail;
37956 PyThreadState* __tstate = wxPyBeginAllowThreads();
37957 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37958 wxPyEndAllowThreads(__tstate);
37959 if (PyErr_Occurred()) SWIG_fail;
37960 }
37961 {
37962 resultobj = wxPyMake_wxObject(result, 0);
37963 }
37964 return resultobj;
37965 fail:
37966 return NULL;
37967 }
37968
37969
37970 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37971 PyObject *resultobj = 0;
37972 wxString *arg1 = 0 ;
37973 wxWindow *arg2 = (wxWindow *) NULL ;
37974 wxWindow *result = 0 ;
37975 bool temp1 = false ;
37976 void *argp2 = 0 ;
37977 int res2 = 0 ;
37978 PyObject * obj0 = 0 ;
37979 PyObject * obj1 = 0 ;
37980 char * kwnames[] = {
37981 (char *) "name",(char *) "parent", NULL
37982 };
37983
37984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37985 {
37986 arg1 = wxString_in_helper(obj0);
37987 if (arg1 == NULL) SWIG_fail;
37988 temp1 = true;
37989 }
37990 if (obj1) {
37991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37992 if (!SWIG_IsOK(res2)) {
37993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37994 }
37995 arg2 = reinterpret_cast< wxWindow * >(argp2);
37996 }
37997 {
37998 if (!wxPyCheckForApp()) SWIG_fail;
37999 PyThreadState* __tstate = wxPyBeginAllowThreads();
38000 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38001 wxPyEndAllowThreads(__tstate);
38002 if (PyErr_Occurred()) SWIG_fail;
38003 }
38004 {
38005 resultobj = wxPyMake_wxObject(result, 0);
38006 }
38007 {
38008 if (temp1)
38009 delete arg1;
38010 }
38011 return resultobj;
38012 fail:
38013 {
38014 if (temp1)
38015 delete arg1;
38016 }
38017 return NULL;
38018 }
38019
38020
38021 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38022 PyObject *resultobj = 0;
38023 wxString *arg1 = 0 ;
38024 wxWindow *arg2 = (wxWindow *) NULL ;
38025 wxWindow *result = 0 ;
38026 bool temp1 = false ;
38027 void *argp2 = 0 ;
38028 int res2 = 0 ;
38029 PyObject * obj0 = 0 ;
38030 PyObject * obj1 = 0 ;
38031 char * kwnames[] = {
38032 (char *) "label",(char *) "parent", NULL
38033 };
38034
38035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38036 {
38037 arg1 = wxString_in_helper(obj0);
38038 if (arg1 == NULL) SWIG_fail;
38039 temp1 = true;
38040 }
38041 if (obj1) {
38042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38043 if (!SWIG_IsOK(res2)) {
38044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38045 }
38046 arg2 = reinterpret_cast< wxWindow * >(argp2);
38047 }
38048 {
38049 if (!wxPyCheckForApp()) SWIG_fail;
38050 PyThreadState* __tstate = wxPyBeginAllowThreads();
38051 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 {
38056 resultobj = wxPyMake_wxObject(result, 0);
38057 }
38058 {
38059 if (temp1)
38060 delete arg1;
38061 }
38062 return resultobj;
38063 fail:
38064 {
38065 if (temp1)
38066 delete arg1;
38067 }
38068 return NULL;
38069 }
38070
38071
38072 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38073 PyObject *resultobj = 0;
38074 wxWindow *arg1 = (wxWindow *) 0 ;
38075 unsigned long arg2 ;
38076 wxWindow *result = 0 ;
38077 void *argp1 = 0 ;
38078 int res1 = 0 ;
38079 unsigned long val2 ;
38080 int ecode2 = 0 ;
38081 PyObject * obj0 = 0 ;
38082 PyObject * obj1 = 0 ;
38083 char * kwnames[] = {
38084 (char *) "parent",(char *) "_hWnd", NULL
38085 };
38086
38087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38089 if (!SWIG_IsOK(res1)) {
38090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38091 }
38092 arg1 = reinterpret_cast< wxWindow * >(argp1);
38093 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38094 if (!SWIG_IsOK(ecode2)) {
38095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38096 }
38097 arg2 = static_cast< unsigned long >(val2);
38098 {
38099 PyThreadState* __tstate = wxPyBeginAllowThreads();
38100 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38101 wxPyEndAllowThreads(__tstate);
38102 if (PyErr_Occurred()) SWIG_fail;
38103 }
38104 {
38105 resultobj = wxPyMake_wxObject(result, 0);
38106 }
38107 return resultobj;
38108 fail:
38109 return NULL;
38110 }
38111
38112
38113 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38114 PyObject *resultobj = 0;
38115 PyObject *result = 0 ;
38116
38117 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 result = (PyObject *)GetTopLevelWindows();
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 resultobj = result;
38125 return resultobj;
38126 fail:
38127 return NULL;
38128 }
38129
38130
38131 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38132 PyObject *resultobj = 0;
38133 wxValidator *result = 0 ;
38134
38135 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 result = (wxValidator *)new wxValidator();
38139 wxPyEndAllowThreads(__tstate);
38140 if (PyErr_Occurred()) SWIG_fail;
38141 }
38142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38143 return resultobj;
38144 fail:
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38150 PyObject *resultobj = 0;
38151 wxValidator *arg1 = (wxValidator *) 0 ;
38152 wxValidator *result = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38162 }
38163 arg1 = reinterpret_cast< wxValidator * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 result = (wxValidator *)(arg1)->Clone();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 {
38171 resultobj = wxPyMake_wxObject(result, 0);
38172 }
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj = 0;
38181 wxValidator *arg1 = (wxValidator *) 0 ;
38182 wxWindow *arg2 = (wxWindow *) 0 ;
38183 bool result;
38184 void *argp1 = 0 ;
38185 int res1 = 0 ;
38186 void *argp2 = 0 ;
38187 int res2 = 0 ;
38188 PyObject * obj0 = 0 ;
38189 PyObject * obj1 = 0 ;
38190 char * kwnames[] = {
38191 (char *) "self",(char *) "parent", NULL
38192 };
38193
38194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38196 if (!SWIG_IsOK(res1)) {
38197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38198 }
38199 arg1 = reinterpret_cast< wxValidator * >(argp1);
38200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38201 if (!SWIG_IsOK(res2)) {
38202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38203 }
38204 arg2 = reinterpret_cast< wxWindow * >(argp2);
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 result = (bool)(arg1)->Validate(arg2);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 {
38212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38213 }
38214 return resultobj;
38215 fail:
38216 return NULL;
38217 }
38218
38219
38220 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38221 PyObject *resultobj = 0;
38222 wxValidator *arg1 = (wxValidator *) 0 ;
38223 bool result;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 PyObject *swig_obj[1] ;
38227
38228 if (!args) SWIG_fail;
38229 swig_obj[0] = args;
38230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38231 if (!SWIG_IsOK(res1)) {
38232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38233 }
38234 arg1 = reinterpret_cast< wxValidator * >(argp1);
38235 {
38236 PyThreadState* __tstate = wxPyBeginAllowThreads();
38237 result = (bool)(arg1)->TransferToWindow();
38238 wxPyEndAllowThreads(__tstate);
38239 if (PyErr_Occurred()) SWIG_fail;
38240 }
38241 {
38242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38243 }
38244 return resultobj;
38245 fail:
38246 return NULL;
38247 }
38248
38249
38250 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38251 PyObject *resultobj = 0;
38252 wxValidator *arg1 = (wxValidator *) 0 ;
38253 bool result;
38254 void *argp1 = 0 ;
38255 int res1 = 0 ;
38256 PyObject *swig_obj[1] ;
38257
38258 if (!args) SWIG_fail;
38259 swig_obj[0] = args;
38260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38261 if (!SWIG_IsOK(res1)) {
38262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38263 }
38264 arg1 = reinterpret_cast< wxValidator * >(argp1);
38265 {
38266 PyThreadState* __tstate = wxPyBeginAllowThreads();
38267 result = (bool)(arg1)->TransferFromWindow();
38268 wxPyEndAllowThreads(__tstate);
38269 if (PyErr_Occurred()) SWIG_fail;
38270 }
38271 {
38272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38273 }
38274 return resultobj;
38275 fail:
38276 return NULL;
38277 }
38278
38279
38280 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38281 PyObject *resultobj = 0;
38282 wxValidator *arg1 = (wxValidator *) 0 ;
38283 wxWindow *result = 0 ;
38284 void *argp1 = 0 ;
38285 int res1 = 0 ;
38286 PyObject *swig_obj[1] ;
38287
38288 if (!args) SWIG_fail;
38289 swig_obj[0] = args;
38290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38291 if (!SWIG_IsOK(res1)) {
38292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38293 }
38294 arg1 = reinterpret_cast< wxValidator * >(argp1);
38295 {
38296 PyThreadState* __tstate = wxPyBeginAllowThreads();
38297 result = (wxWindow *)(arg1)->GetWindow();
38298 wxPyEndAllowThreads(__tstate);
38299 if (PyErr_Occurred()) SWIG_fail;
38300 }
38301 {
38302 resultobj = wxPyMake_wxObject(result, 0);
38303 }
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38311 PyObject *resultobj = 0;
38312 wxValidator *arg1 = (wxValidator *) 0 ;
38313 wxWindow *arg2 = (wxWindow *) 0 ;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 void *argp2 = 0 ;
38317 int res2 = 0 ;
38318 PyObject * obj0 = 0 ;
38319 PyObject * obj1 = 0 ;
38320 char * kwnames[] = {
38321 (char *) "self",(char *) "window", NULL
38322 };
38323
38324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38326 if (!SWIG_IsOK(res1)) {
38327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38328 }
38329 arg1 = reinterpret_cast< wxValidator * >(argp1);
38330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38331 if (!SWIG_IsOK(res2)) {
38332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38333 }
38334 arg2 = reinterpret_cast< wxWindow * >(argp2);
38335 {
38336 PyThreadState* __tstate = wxPyBeginAllowThreads();
38337 (arg1)->SetWindow(arg2);
38338 wxPyEndAllowThreads(__tstate);
38339 if (PyErr_Occurred()) SWIG_fail;
38340 }
38341 resultobj = SWIG_Py_Void();
38342 return resultobj;
38343 fail:
38344 return NULL;
38345 }
38346
38347
38348 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38349 PyObject *resultobj = 0;
38350 bool result;
38351
38352 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38353 {
38354 PyThreadState* __tstate = wxPyBeginAllowThreads();
38355 result = (bool)wxValidator::IsSilent();
38356 wxPyEndAllowThreads(__tstate);
38357 if (PyErr_Occurred()) SWIG_fail;
38358 }
38359 {
38360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38361 }
38362 return resultobj;
38363 fail:
38364 return NULL;
38365 }
38366
38367
38368 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38369 PyObject *resultobj = 0;
38370 int arg1 = (int) true ;
38371 int val1 ;
38372 int ecode1 = 0 ;
38373 PyObject * obj0 = 0 ;
38374 char * kwnames[] = {
38375 (char *) "doIt", NULL
38376 };
38377
38378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38379 if (obj0) {
38380 ecode1 = SWIG_AsVal_int(obj0, &val1);
38381 if (!SWIG_IsOK(ecode1)) {
38382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38383 }
38384 arg1 = static_cast< int >(val1);
38385 }
38386 {
38387 PyThreadState* __tstate = wxPyBeginAllowThreads();
38388 wxValidator::SetBellOnError(arg1);
38389 wxPyEndAllowThreads(__tstate);
38390 if (PyErr_Occurred()) SWIG_fail;
38391 }
38392 resultobj = SWIG_Py_Void();
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38400 PyObject *obj;
38401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38402 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38403 return SWIG_Py_Void();
38404 }
38405
38406 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38407 return SWIG_Python_InitShadowInstance(args);
38408 }
38409
38410 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38411 PyObject *resultobj = 0;
38412 wxPyValidator *result = 0 ;
38413
38414 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38415 {
38416 PyThreadState* __tstate = wxPyBeginAllowThreads();
38417 result = (wxPyValidator *)new wxPyValidator();
38418 wxPyEndAllowThreads(__tstate);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 }
38421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38422 return resultobj;
38423 fail:
38424 return NULL;
38425 }
38426
38427
38428 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38429 PyObject *resultobj = 0;
38430 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38431 PyObject *arg2 = (PyObject *) 0 ;
38432 PyObject *arg3 = (PyObject *) 0 ;
38433 int arg4 = (int) true ;
38434 void *argp1 = 0 ;
38435 int res1 = 0 ;
38436 int val4 ;
38437 int ecode4 = 0 ;
38438 PyObject * obj0 = 0 ;
38439 PyObject * obj1 = 0 ;
38440 PyObject * obj2 = 0 ;
38441 PyObject * obj3 = 0 ;
38442 char * kwnames[] = {
38443 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38444 };
38445
38446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38448 if (!SWIG_IsOK(res1)) {
38449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38450 }
38451 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38452 arg2 = obj1;
38453 arg3 = obj2;
38454 if (obj3) {
38455 ecode4 = SWIG_AsVal_int(obj3, &val4);
38456 if (!SWIG_IsOK(ecode4)) {
38457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38458 }
38459 arg4 = static_cast< int >(val4);
38460 }
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38464 wxPyEndAllowThreads(__tstate);
38465 if (PyErr_Occurred()) SWIG_fail;
38466 }
38467 resultobj = SWIG_Py_Void();
38468 return resultobj;
38469 fail:
38470 return NULL;
38471 }
38472
38473
38474 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38475 PyObject *obj;
38476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38477 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38478 return SWIG_Py_Void();
38479 }
38480
38481 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38482 return SWIG_Python_InitShadowInstance(args);
38483 }
38484
38485 SWIGINTERN int DefaultValidator_set(PyObject *) {
38486 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38487 return 1;
38488 }
38489
38490
38491 SWIGINTERN PyObject *DefaultValidator_get(void) {
38492 PyObject *pyobj = 0;
38493
38494 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38495 return pyobj;
38496 }
38497
38498
38499 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38500 PyObject *resultobj = 0;
38501 wxString const &arg1_defvalue = wxPyEmptyString ;
38502 wxString *arg1 = (wxString *) &arg1_defvalue ;
38503 long arg2 = (long) 0 ;
38504 wxMenu *result = 0 ;
38505 bool temp1 = false ;
38506 long val2 ;
38507 int ecode2 = 0 ;
38508 PyObject * obj0 = 0 ;
38509 PyObject * obj1 = 0 ;
38510 char * kwnames[] = {
38511 (char *) "title",(char *) "style", NULL
38512 };
38513
38514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38515 if (obj0) {
38516 {
38517 arg1 = wxString_in_helper(obj0);
38518 if (arg1 == NULL) SWIG_fail;
38519 temp1 = true;
38520 }
38521 }
38522 if (obj1) {
38523 ecode2 = SWIG_AsVal_long(obj1, &val2);
38524 if (!SWIG_IsOK(ecode2)) {
38525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38526 }
38527 arg2 = static_cast< long >(val2);
38528 }
38529 {
38530 if (!wxPyCheckForApp()) SWIG_fail;
38531 PyThreadState* __tstate = wxPyBeginAllowThreads();
38532 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38533 wxPyEndAllowThreads(__tstate);
38534 if (PyErr_Occurred()) SWIG_fail;
38535 }
38536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38537 {
38538 if (temp1)
38539 delete arg1;
38540 }
38541 return resultobj;
38542 fail:
38543 {
38544 if (temp1)
38545 delete arg1;
38546 }
38547 return NULL;
38548 }
38549
38550
38551 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj = 0;
38553 wxMenu *arg1 = (wxMenu *) 0 ;
38554 int arg2 ;
38555 wxString *arg3 = 0 ;
38556 wxString const &arg4_defvalue = wxPyEmptyString ;
38557 wxString *arg4 = (wxString *) &arg4_defvalue ;
38558 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38559 wxMenuItem *result = 0 ;
38560 void *argp1 = 0 ;
38561 int res1 = 0 ;
38562 int val2 ;
38563 int ecode2 = 0 ;
38564 bool temp3 = false ;
38565 bool temp4 = false ;
38566 int val5 ;
38567 int ecode5 = 0 ;
38568 PyObject * obj0 = 0 ;
38569 PyObject * obj1 = 0 ;
38570 PyObject * obj2 = 0 ;
38571 PyObject * obj3 = 0 ;
38572 PyObject * obj4 = 0 ;
38573 char * kwnames[] = {
38574 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38575 };
38576
38577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38579 if (!SWIG_IsOK(res1)) {
38580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38581 }
38582 arg1 = reinterpret_cast< wxMenu * >(argp1);
38583 ecode2 = SWIG_AsVal_int(obj1, &val2);
38584 if (!SWIG_IsOK(ecode2)) {
38585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38586 }
38587 arg2 = static_cast< int >(val2);
38588 {
38589 arg3 = wxString_in_helper(obj2);
38590 if (arg3 == NULL) SWIG_fail;
38591 temp3 = true;
38592 }
38593 if (obj3) {
38594 {
38595 arg4 = wxString_in_helper(obj3);
38596 if (arg4 == NULL) SWIG_fail;
38597 temp4 = true;
38598 }
38599 }
38600 if (obj4) {
38601 ecode5 = SWIG_AsVal_int(obj4, &val5);
38602 if (!SWIG_IsOK(ecode5)) {
38603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38604 }
38605 arg5 = static_cast< wxItemKind >(val5);
38606 }
38607 {
38608 PyThreadState* __tstate = wxPyBeginAllowThreads();
38609 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38610 wxPyEndAllowThreads(__tstate);
38611 if (PyErr_Occurred()) SWIG_fail;
38612 }
38613 {
38614 resultobj = wxPyMake_wxObject(result, (bool)0);
38615 }
38616 {
38617 if (temp3)
38618 delete arg3;
38619 }
38620 {
38621 if (temp4)
38622 delete arg4;
38623 }
38624 return resultobj;
38625 fail:
38626 {
38627 if (temp3)
38628 delete arg3;
38629 }
38630 {
38631 if (temp4)
38632 delete arg4;
38633 }
38634 return NULL;
38635 }
38636
38637
38638 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38639 PyObject *resultobj = 0;
38640 wxMenu *arg1 = (wxMenu *) 0 ;
38641 wxMenuItem *result = 0 ;
38642 void *argp1 = 0 ;
38643 int res1 = 0 ;
38644 PyObject *swig_obj[1] ;
38645
38646 if (!args) SWIG_fail;
38647 swig_obj[0] = args;
38648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38649 if (!SWIG_IsOK(res1)) {
38650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38651 }
38652 arg1 = reinterpret_cast< wxMenu * >(argp1);
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 result = (wxMenuItem *)(arg1)->AppendSeparator();
38656 wxPyEndAllowThreads(__tstate);
38657 if (PyErr_Occurred()) SWIG_fail;
38658 }
38659 {
38660 resultobj = wxPyMake_wxObject(result, (bool)0);
38661 }
38662 return resultobj;
38663 fail:
38664 return NULL;
38665 }
38666
38667
38668 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38669 PyObject *resultobj = 0;
38670 wxMenu *arg1 = (wxMenu *) 0 ;
38671 int arg2 ;
38672 wxString *arg3 = 0 ;
38673 wxString const &arg4_defvalue = wxPyEmptyString ;
38674 wxString *arg4 = (wxString *) &arg4_defvalue ;
38675 wxMenuItem *result = 0 ;
38676 void *argp1 = 0 ;
38677 int res1 = 0 ;
38678 int val2 ;
38679 int ecode2 = 0 ;
38680 bool temp3 = false ;
38681 bool temp4 = false ;
38682 PyObject * obj0 = 0 ;
38683 PyObject * obj1 = 0 ;
38684 PyObject * obj2 = 0 ;
38685 PyObject * obj3 = 0 ;
38686 char * kwnames[] = {
38687 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38688 };
38689
38690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38692 if (!SWIG_IsOK(res1)) {
38693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38694 }
38695 arg1 = reinterpret_cast< wxMenu * >(argp1);
38696 ecode2 = SWIG_AsVal_int(obj1, &val2);
38697 if (!SWIG_IsOK(ecode2)) {
38698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38699 }
38700 arg2 = static_cast< int >(val2);
38701 {
38702 arg3 = wxString_in_helper(obj2);
38703 if (arg3 == NULL) SWIG_fail;
38704 temp3 = true;
38705 }
38706 if (obj3) {
38707 {
38708 arg4 = wxString_in_helper(obj3);
38709 if (arg4 == NULL) SWIG_fail;
38710 temp4 = true;
38711 }
38712 }
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 {
38720 resultobj = wxPyMake_wxObject(result, (bool)0);
38721 }
38722 {
38723 if (temp3)
38724 delete arg3;
38725 }
38726 {
38727 if (temp4)
38728 delete arg4;
38729 }
38730 return resultobj;
38731 fail:
38732 {
38733 if (temp3)
38734 delete arg3;
38735 }
38736 {
38737 if (temp4)
38738 delete arg4;
38739 }
38740 return NULL;
38741 }
38742
38743
38744 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj = 0;
38746 wxMenu *arg1 = (wxMenu *) 0 ;
38747 int arg2 ;
38748 wxString *arg3 = 0 ;
38749 wxString const &arg4_defvalue = wxPyEmptyString ;
38750 wxString *arg4 = (wxString *) &arg4_defvalue ;
38751 wxMenuItem *result = 0 ;
38752 void *argp1 = 0 ;
38753 int res1 = 0 ;
38754 int val2 ;
38755 int ecode2 = 0 ;
38756 bool temp3 = false ;
38757 bool temp4 = false ;
38758 PyObject * obj0 = 0 ;
38759 PyObject * obj1 = 0 ;
38760 PyObject * obj2 = 0 ;
38761 PyObject * obj3 = 0 ;
38762 char * kwnames[] = {
38763 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38764 };
38765
38766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38768 if (!SWIG_IsOK(res1)) {
38769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38770 }
38771 arg1 = reinterpret_cast< wxMenu * >(argp1);
38772 ecode2 = SWIG_AsVal_int(obj1, &val2);
38773 if (!SWIG_IsOK(ecode2)) {
38774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38775 }
38776 arg2 = static_cast< int >(val2);
38777 {
38778 arg3 = wxString_in_helper(obj2);
38779 if (arg3 == NULL) SWIG_fail;
38780 temp3 = true;
38781 }
38782 if (obj3) {
38783 {
38784 arg4 = wxString_in_helper(obj3);
38785 if (arg4 == NULL) SWIG_fail;
38786 temp4 = true;
38787 }
38788 }
38789 {
38790 PyThreadState* __tstate = wxPyBeginAllowThreads();
38791 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38792 wxPyEndAllowThreads(__tstate);
38793 if (PyErr_Occurred()) SWIG_fail;
38794 }
38795 {
38796 resultobj = wxPyMake_wxObject(result, (bool)0);
38797 }
38798 {
38799 if (temp3)
38800 delete arg3;
38801 }
38802 {
38803 if (temp4)
38804 delete arg4;
38805 }
38806 return resultobj;
38807 fail:
38808 {
38809 if (temp3)
38810 delete arg3;
38811 }
38812 {
38813 if (temp4)
38814 delete arg4;
38815 }
38816 return NULL;
38817 }
38818
38819
38820 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38821 PyObject *resultobj = 0;
38822 wxMenu *arg1 = (wxMenu *) 0 ;
38823 int arg2 ;
38824 wxString *arg3 = 0 ;
38825 wxMenu *arg4 = (wxMenu *) 0 ;
38826 wxString const &arg5_defvalue = wxPyEmptyString ;
38827 wxString *arg5 = (wxString *) &arg5_defvalue ;
38828 wxMenuItem *result = 0 ;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 int val2 ;
38832 int ecode2 = 0 ;
38833 bool temp3 = false ;
38834 void *argp4 = 0 ;
38835 int res4 = 0 ;
38836 bool temp5 = false ;
38837 PyObject * obj0 = 0 ;
38838 PyObject * obj1 = 0 ;
38839 PyObject * obj2 = 0 ;
38840 PyObject * obj3 = 0 ;
38841 PyObject * obj4 = 0 ;
38842 char * kwnames[] = {
38843 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38844 };
38845
38846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38848 if (!SWIG_IsOK(res1)) {
38849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38850 }
38851 arg1 = reinterpret_cast< wxMenu * >(argp1);
38852 ecode2 = SWIG_AsVal_int(obj1, &val2);
38853 if (!SWIG_IsOK(ecode2)) {
38854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38855 }
38856 arg2 = static_cast< int >(val2);
38857 {
38858 arg3 = wxString_in_helper(obj2);
38859 if (arg3 == NULL) SWIG_fail;
38860 temp3 = true;
38861 }
38862 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38863 if (!SWIG_IsOK(res4)) {
38864 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38865 }
38866 arg4 = reinterpret_cast< wxMenu * >(argp4);
38867 if (obj4) {
38868 {
38869 arg5 = wxString_in_helper(obj4);
38870 if (arg5 == NULL) SWIG_fail;
38871 temp5 = true;
38872 }
38873 }
38874 {
38875 PyThreadState* __tstate = wxPyBeginAllowThreads();
38876 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38877 wxPyEndAllowThreads(__tstate);
38878 if (PyErr_Occurred()) SWIG_fail;
38879 }
38880 {
38881 resultobj = wxPyMake_wxObject(result, (bool)0);
38882 }
38883 {
38884 if (temp3)
38885 delete arg3;
38886 }
38887 {
38888 if (temp5)
38889 delete arg5;
38890 }
38891 return resultobj;
38892 fail:
38893 {
38894 if (temp3)
38895 delete arg3;
38896 }
38897 {
38898 if (temp5)
38899 delete arg5;
38900 }
38901 return NULL;
38902 }
38903
38904
38905 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38906 PyObject *resultobj = 0;
38907 wxMenu *arg1 = (wxMenu *) 0 ;
38908 wxMenu *arg2 = (wxMenu *) 0 ;
38909 wxString *arg3 = 0 ;
38910 wxString const &arg4_defvalue = wxPyEmptyString ;
38911 wxString *arg4 = (wxString *) &arg4_defvalue ;
38912 wxMenuItem *result = 0 ;
38913 void *argp1 = 0 ;
38914 int res1 = 0 ;
38915 void *argp2 = 0 ;
38916 int res2 = 0 ;
38917 bool temp3 = false ;
38918 bool temp4 = false ;
38919 PyObject * obj0 = 0 ;
38920 PyObject * obj1 = 0 ;
38921 PyObject * obj2 = 0 ;
38922 PyObject * obj3 = 0 ;
38923 char * kwnames[] = {
38924 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38925 };
38926
38927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38931 }
38932 arg1 = reinterpret_cast< wxMenu * >(argp1);
38933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38934 if (!SWIG_IsOK(res2)) {
38935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38936 }
38937 arg2 = reinterpret_cast< wxMenu * >(argp2);
38938 {
38939 arg3 = wxString_in_helper(obj2);
38940 if (arg3 == NULL) SWIG_fail;
38941 temp3 = true;
38942 }
38943 if (obj3) {
38944 {
38945 arg4 = wxString_in_helper(obj3);
38946 if (arg4 == NULL) SWIG_fail;
38947 temp4 = true;
38948 }
38949 }
38950 {
38951 PyThreadState* __tstate = wxPyBeginAllowThreads();
38952 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38953 wxPyEndAllowThreads(__tstate);
38954 if (PyErr_Occurred()) SWIG_fail;
38955 }
38956 {
38957 resultobj = wxPyMake_wxObject(result, (bool)0);
38958 }
38959 {
38960 if (temp3)
38961 delete arg3;
38962 }
38963 {
38964 if (temp4)
38965 delete arg4;
38966 }
38967 return resultobj;
38968 fail:
38969 {
38970 if (temp3)
38971 delete arg3;
38972 }
38973 {
38974 if (temp4)
38975 delete arg4;
38976 }
38977 return NULL;
38978 }
38979
38980
38981 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj = 0;
38983 wxMenu *arg1 = (wxMenu *) 0 ;
38984 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38985 wxMenuItem *result = 0 ;
38986 void *argp1 = 0 ;
38987 int res1 = 0 ;
38988 int res2 = 0 ;
38989 PyObject * obj0 = 0 ;
38990 PyObject * obj1 = 0 ;
38991 char * kwnames[] = {
38992 (char *) "self",(char *) "item", NULL
38993 };
38994
38995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38997 if (!SWIG_IsOK(res1)) {
38998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38999 }
39000 arg1 = reinterpret_cast< wxMenu * >(argp1);
39001 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39002 if (!SWIG_IsOK(res2)) {
39003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39004 }
39005 {
39006 PyThreadState* __tstate = wxPyBeginAllowThreads();
39007 result = (wxMenuItem *)(arg1)->Append(arg2);
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 {
39012 resultobj = wxPyMake_wxObject(result, (bool)0);
39013 }
39014 return resultobj;
39015 fail:
39016 return NULL;
39017 }
39018
39019
39020 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39021 PyObject *resultobj = 0;
39022 wxMenu *arg1 = (wxMenu *) 0 ;
39023 size_t arg2 ;
39024 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39025 wxMenuItem *result = 0 ;
39026 void *argp1 = 0 ;
39027 int res1 = 0 ;
39028 size_t val2 ;
39029 int ecode2 = 0 ;
39030 int res3 = 0 ;
39031 PyObject * obj0 = 0 ;
39032 PyObject * obj1 = 0 ;
39033 PyObject * obj2 = 0 ;
39034 char * kwnames[] = {
39035 (char *) "self",(char *) "pos",(char *) "item", NULL
39036 };
39037
39038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39040 if (!SWIG_IsOK(res1)) {
39041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39042 }
39043 arg1 = reinterpret_cast< wxMenu * >(argp1);
39044 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39045 if (!SWIG_IsOK(ecode2)) {
39046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39047 }
39048 arg2 = static_cast< size_t >(val2);
39049 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39050 if (!SWIG_IsOK(res3)) {
39051 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39052 }
39053 {
39054 PyThreadState* __tstate = wxPyBeginAllowThreads();
39055 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39056 wxPyEndAllowThreads(__tstate);
39057 if (PyErr_Occurred()) SWIG_fail;
39058 }
39059 {
39060 resultobj = wxPyMake_wxObject(result, (bool)0);
39061 }
39062 return resultobj;
39063 fail:
39064 return NULL;
39065 }
39066
39067
39068 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39069 PyObject *resultobj = 0;
39070 wxMenu *arg1 = (wxMenu *) 0 ;
39071 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39072 wxMenuItem *result = 0 ;
39073 void *argp1 = 0 ;
39074 int res1 = 0 ;
39075 int res2 = 0 ;
39076 PyObject * obj0 = 0 ;
39077 PyObject * obj1 = 0 ;
39078 char * kwnames[] = {
39079 (char *) "self",(char *) "item", NULL
39080 };
39081
39082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39084 if (!SWIG_IsOK(res1)) {
39085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39086 }
39087 arg1 = reinterpret_cast< wxMenu * >(argp1);
39088 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39089 if (!SWIG_IsOK(res2)) {
39090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39091 }
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 resultobj = wxPyMake_wxObject(result, (bool)0);
39100 }
39101 return resultobj;
39102 fail:
39103 return NULL;
39104 }
39105
39106
39107 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39108 PyObject *resultobj = 0;
39109 wxMenu *arg1 = (wxMenu *) 0 ;
39110 void *argp1 = 0 ;
39111 int res1 = 0 ;
39112 PyObject *swig_obj[1] ;
39113
39114 if (!args) SWIG_fail;
39115 swig_obj[0] = args;
39116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39117 if (!SWIG_IsOK(res1)) {
39118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39119 }
39120 arg1 = reinterpret_cast< wxMenu * >(argp1);
39121 {
39122 PyThreadState* __tstate = wxPyBeginAllowThreads();
39123 (arg1)->Break();
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 resultobj = SWIG_Py_Void();
39128 return resultobj;
39129 fail:
39130 return NULL;
39131 }
39132
39133
39134 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj = 0;
39136 wxMenu *arg1 = (wxMenu *) 0 ;
39137 size_t arg2 ;
39138 int arg3 ;
39139 wxString *arg4 = 0 ;
39140 wxString const &arg5_defvalue = wxPyEmptyString ;
39141 wxString *arg5 = (wxString *) &arg5_defvalue ;
39142 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39143 wxMenuItem *result = 0 ;
39144 void *argp1 = 0 ;
39145 int res1 = 0 ;
39146 size_t val2 ;
39147 int ecode2 = 0 ;
39148 int val3 ;
39149 int ecode3 = 0 ;
39150 bool temp4 = false ;
39151 bool temp5 = false ;
39152 int val6 ;
39153 int ecode6 = 0 ;
39154 PyObject * obj0 = 0 ;
39155 PyObject * obj1 = 0 ;
39156 PyObject * obj2 = 0 ;
39157 PyObject * obj3 = 0 ;
39158 PyObject * obj4 = 0 ;
39159 PyObject * obj5 = 0 ;
39160 char * kwnames[] = {
39161 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39162 };
39163
39164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39166 if (!SWIG_IsOK(res1)) {
39167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39168 }
39169 arg1 = reinterpret_cast< wxMenu * >(argp1);
39170 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39171 if (!SWIG_IsOK(ecode2)) {
39172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39173 }
39174 arg2 = static_cast< size_t >(val2);
39175 ecode3 = SWIG_AsVal_int(obj2, &val3);
39176 if (!SWIG_IsOK(ecode3)) {
39177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39178 }
39179 arg3 = static_cast< int >(val3);
39180 {
39181 arg4 = wxString_in_helper(obj3);
39182 if (arg4 == NULL) SWIG_fail;
39183 temp4 = true;
39184 }
39185 if (obj4) {
39186 {
39187 arg5 = wxString_in_helper(obj4);
39188 if (arg5 == NULL) SWIG_fail;
39189 temp5 = true;
39190 }
39191 }
39192 if (obj5) {
39193 ecode6 = SWIG_AsVal_int(obj5, &val6);
39194 if (!SWIG_IsOK(ecode6)) {
39195 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39196 }
39197 arg6 = static_cast< wxItemKind >(val6);
39198 }
39199 {
39200 PyThreadState* __tstate = wxPyBeginAllowThreads();
39201 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39202 wxPyEndAllowThreads(__tstate);
39203 if (PyErr_Occurred()) SWIG_fail;
39204 }
39205 {
39206 resultobj = wxPyMake_wxObject(result, (bool)0);
39207 }
39208 {
39209 if (temp4)
39210 delete arg4;
39211 }
39212 {
39213 if (temp5)
39214 delete arg5;
39215 }
39216 return resultobj;
39217 fail:
39218 {
39219 if (temp4)
39220 delete arg4;
39221 }
39222 {
39223 if (temp5)
39224 delete arg5;
39225 }
39226 return NULL;
39227 }
39228
39229
39230 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39231 PyObject *resultobj = 0;
39232 wxMenu *arg1 = (wxMenu *) 0 ;
39233 size_t arg2 ;
39234 wxMenuItem *result = 0 ;
39235 void *argp1 = 0 ;
39236 int res1 = 0 ;
39237 size_t val2 ;
39238 int ecode2 = 0 ;
39239 PyObject * obj0 = 0 ;
39240 PyObject * obj1 = 0 ;
39241 char * kwnames[] = {
39242 (char *) "self",(char *) "pos", NULL
39243 };
39244
39245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39247 if (!SWIG_IsOK(res1)) {
39248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39249 }
39250 arg1 = reinterpret_cast< wxMenu * >(argp1);
39251 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39252 if (!SWIG_IsOK(ecode2)) {
39253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39254 }
39255 arg2 = static_cast< size_t >(val2);
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 {
39263 resultobj = wxPyMake_wxObject(result, (bool)0);
39264 }
39265 return resultobj;
39266 fail:
39267 return NULL;
39268 }
39269
39270
39271 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39272 PyObject *resultobj = 0;
39273 wxMenu *arg1 = (wxMenu *) 0 ;
39274 size_t arg2 ;
39275 int arg3 ;
39276 wxString *arg4 = 0 ;
39277 wxString const &arg5_defvalue = wxPyEmptyString ;
39278 wxString *arg5 = (wxString *) &arg5_defvalue ;
39279 wxMenuItem *result = 0 ;
39280 void *argp1 = 0 ;
39281 int res1 = 0 ;
39282 size_t val2 ;
39283 int ecode2 = 0 ;
39284 int val3 ;
39285 int ecode3 = 0 ;
39286 bool temp4 = false ;
39287 bool temp5 = false ;
39288 PyObject * obj0 = 0 ;
39289 PyObject * obj1 = 0 ;
39290 PyObject * obj2 = 0 ;
39291 PyObject * obj3 = 0 ;
39292 PyObject * obj4 = 0 ;
39293 char * kwnames[] = {
39294 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39295 };
39296
39297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39299 if (!SWIG_IsOK(res1)) {
39300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39301 }
39302 arg1 = reinterpret_cast< wxMenu * >(argp1);
39303 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39304 if (!SWIG_IsOK(ecode2)) {
39305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39306 }
39307 arg2 = static_cast< size_t >(val2);
39308 ecode3 = SWIG_AsVal_int(obj2, &val3);
39309 if (!SWIG_IsOK(ecode3)) {
39310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39311 }
39312 arg3 = static_cast< int >(val3);
39313 {
39314 arg4 = wxString_in_helper(obj3);
39315 if (arg4 == NULL) SWIG_fail;
39316 temp4 = true;
39317 }
39318 if (obj4) {
39319 {
39320 arg5 = wxString_in_helper(obj4);
39321 if (arg5 == NULL) SWIG_fail;
39322 temp5 = true;
39323 }
39324 }
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39328 wxPyEndAllowThreads(__tstate);
39329 if (PyErr_Occurred()) SWIG_fail;
39330 }
39331 {
39332 resultobj = wxPyMake_wxObject(result, (bool)0);
39333 }
39334 {
39335 if (temp4)
39336 delete arg4;
39337 }
39338 {
39339 if (temp5)
39340 delete arg5;
39341 }
39342 return resultobj;
39343 fail:
39344 {
39345 if (temp4)
39346 delete arg4;
39347 }
39348 {
39349 if (temp5)
39350 delete arg5;
39351 }
39352 return NULL;
39353 }
39354
39355
39356 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39357 PyObject *resultobj = 0;
39358 wxMenu *arg1 = (wxMenu *) 0 ;
39359 size_t arg2 ;
39360 int arg3 ;
39361 wxString *arg4 = 0 ;
39362 wxString const &arg5_defvalue = wxPyEmptyString ;
39363 wxString *arg5 = (wxString *) &arg5_defvalue ;
39364 wxMenuItem *result = 0 ;
39365 void *argp1 = 0 ;
39366 int res1 = 0 ;
39367 size_t val2 ;
39368 int ecode2 = 0 ;
39369 int val3 ;
39370 int ecode3 = 0 ;
39371 bool temp4 = false ;
39372 bool temp5 = false ;
39373 PyObject * obj0 = 0 ;
39374 PyObject * obj1 = 0 ;
39375 PyObject * obj2 = 0 ;
39376 PyObject * obj3 = 0 ;
39377 PyObject * obj4 = 0 ;
39378 char * kwnames[] = {
39379 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39380 };
39381
39382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39384 if (!SWIG_IsOK(res1)) {
39385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39386 }
39387 arg1 = reinterpret_cast< wxMenu * >(argp1);
39388 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39389 if (!SWIG_IsOK(ecode2)) {
39390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39391 }
39392 arg2 = static_cast< size_t >(val2);
39393 ecode3 = SWIG_AsVal_int(obj2, &val3);
39394 if (!SWIG_IsOK(ecode3)) {
39395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39396 }
39397 arg3 = static_cast< int >(val3);
39398 {
39399 arg4 = wxString_in_helper(obj3);
39400 if (arg4 == NULL) SWIG_fail;
39401 temp4 = true;
39402 }
39403 if (obj4) {
39404 {
39405 arg5 = wxString_in_helper(obj4);
39406 if (arg5 == NULL) SWIG_fail;
39407 temp5 = true;
39408 }
39409 }
39410 {
39411 PyThreadState* __tstate = wxPyBeginAllowThreads();
39412 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39413 wxPyEndAllowThreads(__tstate);
39414 if (PyErr_Occurred()) SWIG_fail;
39415 }
39416 {
39417 resultobj = wxPyMake_wxObject(result, (bool)0);
39418 }
39419 {
39420 if (temp4)
39421 delete arg4;
39422 }
39423 {
39424 if (temp5)
39425 delete arg5;
39426 }
39427 return resultobj;
39428 fail:
39429 {
39430 if (temp4)
39431 delete arg4;
39432 }
39433 {
39434 if (temp5)
39435 delete arg5;
39436 }
39437 return NULL;
39438 }
39439
39440
39441 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39442 PyObject *resultobj = 0;
39443 wxMenu *arg1 = (wxMenu *) 0 ;
39444 size_t arg2 ;
39445 int arg3 ;
39446 wxString *arg4 = 0 ;
39447 wxMenu *arg5 = (wxMenu *) 0 ;
39448 wxString const &arg6_defvalue = wxPyEmptyString ;
39449 wxString *arg6 = (wxString *) &arg6_defvalue ;
39450 wxMenuItem *result = 0 ;
39451 void *argp1 = 0 ;
39452 int res1 = 0 ;
39453 size_t val2 ;
39454 int ecode2 = 0 ;
39455 int val3 ;
39456 int ecode3 = 0 ;
39457 bool temp4 = false ;
39458 void *argp5 = 0 ;
39459 int res5 = 0 ;
39460 bool temp6 = false ;
39461 PyObject * obj0 = 0 ;
39462 PyObject * obj1 = 0 ;
39463 PyObject * obj2 = 0 ;
39464 PyObject * obj3 = 0 ;
39465 PyObject * obj4 = 0 ;
39466 PyObject * obj5 = 0 ;
39467 char * kwnames[] = {
39468 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39469 };
39470
39471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39473 if (!SWIG_IsOK(res1)) {
39474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39475 }
39476 arg1 = reinterpret_cast< wxMenu * >(argp1);
39477 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39478 if (!SWIG_IsOK(ecode2)) {
39479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39480 }
39481 arg2 = static_cast< size_t >(val2);
39482 ecode3 = SWIG_AsVal_int(obj2, &val3);
39483 if (!SWIG_IsOK(ecode3)) {
39484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39485 }
39486 arg3 = static_cast< int >(val3);
39487 {
39488 arg4 = wxString_in_helper(obj3);
39489 if (arg4 == NULL) SWIG_fail;
39490 temp4 = true;
39491 }
39492 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39493 if (!SWIG_IsOK(res5)) {
39494 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39495 }
39496 arg5 = reinterpret_cast< wxMenu * >(argp5);
39497 if (obj5) {
39498 {
39499 arg6 = wxString_in_helper(obj5);
39500 if (arg6 == NULL) SWIG_fail;
39501 temp6 = true;
39502 }
39503 }
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 {
39511 resultobj = wxPyMake_wxObject(result, (bool)0);
39512 }
39513 {
39514 if (temp4)
39515 delete arg4;
39516 }
39517 {
39518 if (temp6)
39519 delete arg6;
39520 }
39521 return resultobj;
39522 fail:
39523 {
39524 if (temp4)
39525 delete arg4;
39526 }
39527 {
39528 if (temp6)
39529 delete arg6;
39530 }
39531 return NULL;
39532 }
39533
39534
39535 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39536 PyObject *resultobj = 0;
39537 wxMenu *arg1 = (wxMenu *) 0 ;
39538 int arg2 ;
39539 wxString *arg3 = 0 ;
39540 wxString const &arg4_defvalue = wxPyEmptyString ;
39541 wxString *arg4 = (wxString *) &arg4_defvalue ;
39542 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39543 wxMenuItem *result = 0 ;
39544 void *argp1 = 0 ;
39545 int res1 = 0 ;
39546 int val2 ;
39547 int ecode2 = 0 ;
39548 bool temp3 = false ;
39549 bool temp4 = false ;
39550 int val5 ;
39551 int ecode5 = 0 ;
39552 PyObject * obj0 = 0 ;
39553 PyObject * obj1 = 0 ;
39554 PyObject * obj2 = 0 ;
39555 PyObject * obj3 = 0 ;
39556 PyObject * obj4 = 0 ;
39557 char * kwnames[] = {
39558 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39559 };
39560
39561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39563 if (!SWIG_IsOK(res1)) {
39564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39565 }
39566 arg1 = reinterpret_cast< wxMenu * >(argp1);
39567 ecode2 = SWIG_AsVal_int(obj1, &val2);
39568 if (!SWIG_IsOK(ecode2)) {
39569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39570 }
39571 arg2 = static_cast< int >(val2);
39572 {
39573 arg3 = wxString_in_helper(obj2);
39574 if (arg3 == NULL) SWIG_fail;
39575 temp3 = true;
39576 }
39577 if (obj3) {
39578 {
39579 arg4 = wxString_in_helper(obj3);
39580 if (arg4 == NULL) SWIG_fail;
39581 temp4 = true;
39582 }
39583 }
39584 if (obj4) {
39585 ecode5 = SWIG_AsVal_int(obj4, &val5);
39586 if (!SWIG_IsOK(ecode5)) {
39587 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39588 }
39589 arg5 = static_cast< wxItemKind >(val5);
39590 }
39591 {
39592 PyThreadState* __tstate = wxPyBeginAllowThreads();
39593 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39594 wxPyEndAllowThreads(__tstate);
39595 if (PyErr_Occurred()) SWIG_fail;
39596 }
39597 {
39598 resultobj = wxPyMake_wxObject(result, (bool)0);
39599 }
39600 {
39601 if (temp3)
39602 delete arg3;
39603 }
39604 {
39605 if (temp4)
39606 delete arg4;
39607 }
39608 return resultobj;
39609 fail:
39610 {
39611 if (temp3)
39612 delete arg3;
39613 }
39614 {
39615 if (temp4)
39616 delete arg4;
39617 }
39618 return NULL;
39619 }
39620
39621
39622 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39623 PyObject *resultobj = 0;
39624 wxMenu *arg1 = (wxMenu *) 0 ;
39625 wxMenuItem *result = 0 ;
39626 void *argp1 = 0 ;
39627 int res1 = 0 ;
39628 PyObject *swig_obj[1] ;
39629
39630 if (!args) SWIG_fail;
39631 swig_obj[0] = args;
39632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39633 if (!SWIG_IsOK(res1)) {
39634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39635 }
39636 arg1 = reinterpret_cast< wxMenu * >(argp1);
39637 {
39638 PyThreadState* __tstate = wxPyBeginAllowThreads();
39639 result = (wxMenuItem *)(arg1)->PrependSeparator();
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 {
39644 resultobj = wxPyMake_wxObject(result, (bool)0);
39645 }
39646 return resultobj;
39647 fail:
39648 return NULL;
39649 }
39650
39651
39652 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj = 0;
39654 wxMenu *arg1 = (wxMenu *) 0 ;
39655 int arg2 ;
39656 wxString *arg3 = 0 ;
39657 wxString const &arg4_defvalue = wxPyEmptyString ;
39658 wxString *arg4 = (wxString *) &arg4_defvalue ;
39659 wxMenuItem *result = 0 ;
39660 void *argp1 = 0 ;
39661 int res1 = 0 ;
39662 int val2 ;
39663 int ecode2 = 0 ;
39664 bool temp3 = false ;
39665 bool temp4 = false ;
39666 PyObject * obj0 = 0 ;
39667 PyObject * obj1 = 0 ;
39668 PyObject * obj2 = 0 ;
39669 PyObject * obj3 = 0 ;
39670 char * kwnames[] = {
39671 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39672 };
39673
39674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39676 if (!SWIG_IsOK(res1)) {
39677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39678 }
39679 arg1 = reinterpret_cast< wxMenu * >(argp1);
39680 ecode2 = SWIG_AsVal_int(obj1, &val2);
39681 if (!SWIG_IsOK(ecode2)) {
39682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39683 }
39684 arg2 = static_cast< int >(val2);
39685 {
39686 arg3 = wxString_in_helper(obj2);
39687 if (arg3 == NULL) SWIG_fail;
39688 temp3 = true;
39689 }
39690 if (obj3) {
39691 {
39692 arg4 = wxString_in_helper(obj3);
39693 if (arg4 == NULL) SWIG_fail;
39694 temp4 = true;
39695 }
39696 }
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39700 wxPyEndAllowThreads(__tstate);
39701 if (PyErr_Occurred()) SWIG_fail;
39702 }
39703 {
39704 resultobj = wxPyMake_wxObject(result, (bool)0);
39705 }
39706 {
39707 if (temp3)
39708 delete arg3;
39709 }
39710 {
39711 if (temp4)
39712 delete arg4;
39713 }
39714 return resultobj;
39715 fail:
39716 {
39717 if (temp3)
39718 delete arg3;
39719 }
39720 {
39721 if (temp4)
39722 delete arg4;
39723 }
39724 return NULL;
39725 }
39726
39727
39728 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39729 PyObject *resultobj = 0;
39730 wxMenu *arg1 = (wxMenu *) 0 ;
39731 int arg2 ;
39732 wxString *arg3 = 0 ;
39733 wxString const &arg4_defvalue = wxPyEmptyString ;
39734 wxString *arg4 = (wxString *) &arg4_defvalue ;
39735 wxMenuItem *result = 0 ;
39736 void *argp1 = 0 ;
39737 int res1 = 0 ;
39738 int val2 ;
39739 int ecode2 = 0 ;
39740 bool temp3 = false ;
39741 bool temp4 = false ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 PyObject * obj2 = 0 ;
39745 PyObject * obj3 = 0 ;
39746 char * kwnames[] = {
39747 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39748 };
39749
39750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39752 if (!SWIG_IsOK(res1)) {
39753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39754 }
39755 arg1 = reinterpret_cast< wxMenu * >(argp1);
39756 ecode2 = SWIG_AsVal_int(obj1, &val2);
39757 if (!SWIG_IsOK(ecode2)) {
39758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39759 }
39760 arg2 = static_cast< int >(val2);
39761 {
39762 arg3 = wxString_in_helper(obj2);
39763 if (arg3 == NULL) SWIG_fail;
39764 temp3 = true;
39765 }
39766 if (obj3) {
39767 {
39768 arg4 = wxString_in_helper(obj3);
39769 if (arg4 == NULL) SWIG_fail;
39770 temp4 = true;
39771 }
39772 }
39773 {
39774 PyThreadState* __tstate = wxPyBeginAllowThreads();
39775 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39776 wxPyEndAllowThreads(__tstate);
39777 if (PyErr_Occurred()) SWIG_fail;
39778 }
39779 {
39780 resultobj = wxPyMake_wxObject(result, (bool)0);
39781 }
39782 {
39783 if (temp3)
39784 delete arg3;
39785 }
39786 {
39787 if (temp4)
39788 delete arg4;
39789 }
39790 return resultobj;
39791 fail:
39792 {
39793 if (temp3)
39794 delete arg3;
39795 }
39796 {
39797 if (temp4)
39798 delete arg4;
39799 }
39800 return NULL;
39801 }
39802
39803
39804 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39805 PyObject *resultobj = 0;
39806 wxMenu *arg1 = (wxMenu *) 0 ;
39807 int arg2 ;
39808 wxString *arg3 = 0 ;
39809 wxMenu *arg4 = (wxMenu *) 0 ;
39810 wxString const &arg5_defvalue = wxPyEmptyString ;
39811 wxString *arg5 = (wxString *) &arg5_defvalue ;
39812 wxMenuItem *result = 0 ;
39813 void *argp1 = 0 ;
39814 int res1 = 0 ;
39815 int val2 ;
39816 int ecode2 = 0 ;
39817 bool temp3 = false ;
39818 void *argp4 = 0 ;
39819 int res4 = 0 ;
39820 bool temp5 = false ;
39821 PyObject * obj0 = 0 ;
39822 PyObject * obj1 = 0 ;
39823 PyObject * obj2 = 0 ;
39824 PyObject * obj3 = 0 ;
39825 PyObject * obj4 = 0 ;
39826 char * kwnames[] = {
39827 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39828 };
39829
39830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39832 if (!SWIG_IsOK(res1)) {
39833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39834 }
39835 arg1 = reinterpret_cast< wxMenu * >(argp1);
39836 ecode2 = SWIG_AsVal_int(obj1, &val2);
39837 if (!SWIG_IsOK(ecode2)) {
39838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39839 }
39840 arg2 = static_cast< int >(val2);
39841 {
39842 arg3 = wxString_in_helper(obj2);
39843 if (arg3 == NULL) SWIG_fail;
39844 temp3 = true;
39845 }
39846 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39847 if (!SWIG_IsOK(res4)) {
39848 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39849 }
39850 arg4 = reinterpret_cast< wxMenu * >(argp4);
39851 if (obj4) {
39852 {
39853 arg5 = wxString_in_helper(obj4);
39854 if (arg5 == NULL) SWIG_fail;
39855 temp5 = true;
39856 }
39857 }
39858 {
39859 PyThreadState* __tstate = wxPyBeginAllowThreads();
39860 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39861 wxPyEndAllowThreads(__tstate);
39862 if (PyErr_Occurred()) SWIG_fail;
39863 }
39864 {
39865 resultobj = wxPyMake_wxObject(result, (bool)0);
39866 }
39867 {
39868 if (temp3)
39869 delete arg3;
39870 }
39871 {
39872 if (temp5)
39873 delete arg5;
39874 }
39875 return resultobj;
39876 fail:
39877 {
39878 if (temp3)
39879 delete arg3;
39880 }
39881 {
39882 if (temp5)
39883 delete arg5;
39884 }
39885 return NULL;
39886 }
39887
39888
39889 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39890 PyObject *resultobj = 0;
39891 wxMenu *arg1 = (wxMenu *) 0 ;
39892 int arg2 ;
39893 wxMenuItem *result = 0 ;
39894 void *argp1 = 0 ;
39895 int res1 = 0 ;
39896 int val2 ;
39897 int ecode2 = 0 ;
39898 PyObject * obj0 = 0 ;
39899 PyObject * obj1 = 0 ;
39900 char * kwnames[] = {
39901 (char *) "self",(char *) "id", NULL
39902 };
39903
39904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39906 if (!SWIG_IsOK(res1)) {
39907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39908 }
39909 arg1 = reinterpret_cast< wxMenu * >(argp1);
39910 ecode2 = SWIG_AsVal_int(obj1, &val2);
39911 if (!SWIG_IsOK(ecode2)) {
39912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39913 }
39914 arg2 = static_cast< int >(val2);
39915 {
39916 PyThreadState* __tstate = wxPyBeginAllowThreads();
39917 result = (wxMenuItem *)(arg1)->Remove(arg2);
39918 wxPyEndAllowThreads(__tstate);
39919 if (PyErr_Occurred()) SWIG_fail;
39920 }
39921 {
39922 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39923 }
39924 return resultobj;
39925 fail:
39926 return NULL;
39927 }
39928
39929
39930 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39931 PyObject *resultobj = 0;
39932 wxMenu *arg1 = (wxMenu *) 0 ;
39933 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39934 wxMenuItem *result = 0 ;
39935 void *argp1 = 0 ;
39936 int res1 = 0 ;
39937 void *argp2 = 0 ;
39938 int res2 = 0 ;
39939 PyObject * obj0 = 0 ;
39940 PyObject * obj1 = 0 ;
39941 char * kwnames[] = {
39942 (char *) "self",(char *) "item", NULL
39943 };
39944
39945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39947 if (!SWIG_IsOK(res1)) {
39948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39949 }
39950 arg1 = reinterpret_cast< wxMenu * >(argp1);
39951 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39952 if (!SWIG_IsOK(res2)) {
39953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39954 }
39955 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39956 {
39957 PyThreadState* __tstate = wxPyBeginAllowThreads();
39958 result = (wxMenuItem *)(arg1)->Remove(arg2);
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 {
39963 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39964 }
39965 return resultobj;
39966 fail:
39967 return NULL;
39968 }
39969
39970
39971 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39972 PyObject *resultobj = 0;
39973 wxMenu *arg1 = (wxMenu *) 0 ;
39974 int arg2 ;
39975 bool result;
39976 void *argp1 = 0 ;
39977 int res1 = 0 ;
39978 int val2 ;
39979 int ecode2 = 0 ;
39980 PyObject * obj0 = 0 ;
39981 PyObject * obj1 = 0 ;
39982 char * kwnames[] = {
39983 (char *) "self",(char *) "id", NULL
39984 };
39985
39986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39988 if (!SWIG_IsOK(res1)) {
39989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39990 }
39991 arg1 = reinterpret_cast< wxMenu * >(argp1);
39992 ecode2 = SWIG_AsVal_int(obj1, &val2);
39993 if (!SWIG_IsOK(ecode2)) {
39994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39995 }
39996 arg2 = static_cast< int >(val2);
39997 {
39998 PyThreadState* __tstate = wxPyBeginAllowThreads();
39999 result = (bool)(arg1)->Delete(arg2);
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 {
40004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj = 0;
40014 wxMenu *arg1 = (wxMenu *) 0 ;
40015 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40016 bool result;
40017 void *argp1 = 0 ;
40018 int res1 = 0 ;
40019 void *argp2 = 0 ;
40020 int res2 = 0 ;
40021 PyObject * obj0 = 0 ;
40022 PyObject * obj1 = 0 ;
40023 char * kwnames[] = {
40024 (char *) "self",(char *) "item", NULL
40025 };
40026
40027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40029 if (!SWIG_IsOK(res1)) {
40030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40031 }
40032 arg1 = reinterpret_cast< wxMenu * >(argp1);
40033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40034 if (!SWIG_IsOK(res2)) {
40035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40036 }
40037 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 result = (bool)(arg1)->Delete(arg2);
40041 wxPyEndAllowThreads(__tstate);
40042 if (PyErr_Occurred()) SWIG_fail;
40043 }
40044 {
40045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40046 }
40047 return resultobj;
40048 fail:
40049 return NULL;
40050 }
40051
40052
40053 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40054 PyObject *resultobj = 0;
40055 wxMenu *arg1 = (wxMenu *) 0 ;
40056 void *argp1 = 0 ;
40057 int res1 = 0 ;
40058 PyObject *swig_obj[1] ;
40059
40060 if (!args) SWIG_fail;
40061 swig_obj[0] = args;
40062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40063 if (!SWIG_IsOK(res1)) {
40064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40065 }
40066 arg1 = reinterpret_cast< wxMenu * >(argp1);
40067 {
40068 PyThreadState* __tstate = wxPyBeginAllowThreads();
40069 wxMenu_Destroy(arg1);
40070 wxPyEndAllowThreads(__tstate);
40071 if (PyErr_Occurred()) SWIG_fail;
40072 }
40073 resultobj = SWIG_Py_Void();
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj = 0;
40082 wxMenu *arg1 = (wxMenu *) 0 ;
40083 int arg2 ;
40084 bool result;
40085 void *argp1 = 0 ;
40086 int res1 = 0 ;
40087 int val2 ;
40088 int ecode2 = 0 ;
40089 PyObject * obj0 = 0 ;
40090 PyObject * obj1 = 0 ;
40091 char * kwnames[] = {
40092 (char *) "self",(char *) "id", NULL
40093 };
40094
40095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40097 if (!SWIG_IsOK(res1)) {
40098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40099 }
40100 arg1 = reinterpret_cast< wxMenu * >(argp1);
40101 ecode2 = SWIG_AsVal_int(obj1, &val2);
40102 if (!SWIG_IsOK(ecode2)) {
40103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40104 }
40105 arg2 = static_cast< int >(val2);
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 result = (bool)(arg1)->Destroy(arg2);
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 {
40113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40114 }
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj = 0;
40123 wxMenu *arg1 = (wxMenu *) 0 ;
40124 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40125 bool result;
40126 void *argp1 = 0 ;
40127 int res1 = 0 ;
40128 void *argp2 = 0 ;
40129 int res2 = 0 ;
40130 PyObject * obj0 = 0 ;
40131 PyObject * obj1 = 0 ;
40132 char * kwnames[] = {
40133 (char *) "self",(char *) "item", NULL
40134 };
40135
40136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40138 if (!SWIG_IsOK(res1)) {
40139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40140 }
40141 arg1 = reinterpret_cast< wxMenu * >(argp1);
40142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40143 if (!SWIG_IsOK(res2)) {
40144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40145 }
40146 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 result = (bool)(arg1)->Destroy(arg2);
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 {
40154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40155 }
40156 return resultobj;
40157 fail:
40158 return NULL;
40159 }
40160
40161
40162 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40163 PyObject *resultobj = 0;
40164 wxMenu *arg1 = (wxMenu *) 0 ;
40165 size_t result;
40166 void *argp1 = 0 ;
40167 int res1 = 0 ;
40168 PyObject *swig_obj[1] ;
40169
40170 if (!args) SWIG_fail;
40171 swig_obj[0] = args;
40172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40173 if (!SWIG_IsOK(res1)) {
40174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40175 }
40176 arg1 = reinterpret_cast< wxMenu * >(argp1);
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40180 wxPyEndAllowThreads(__tstate);
40181 if (PyErr_Occurred()) SWIG_fail;
40182 }
40183 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40184 return resultobj;
40185 fail:
40186 return NULL;
40187 }
40188
40189
40190 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40191 PyObject *resultobj = 0;
40192 wxMenu *arg1 = (wxMenu *) 0 ;
40193 PyObject *result = 0 ;
40194 void *argp1 = 0 ;
40195 int res1 = 0 ;
40196 PyObject *swig_obj[1] ;
40197
40198 if (!args) SWIG_fail;
40199 swig_obj[0] = args;
40200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40201 if (!SWIG_IsOK(res1)) {
40202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40203 }
40204 arg1 = reinterpret_cast< wxMenu * >(argp1);
40205 {
40206 PyThreadState* __tstate = wxPyBeginAllowThreads();
40207 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 resultobj = result;
40212 return resultobj;
40213 fail:
40214 return NULL;
40215 }
40216
40217
40218 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40219 PyObject *resultobj = 0;
40220 wxMenu *arg1 = (wxMenu *) 0 ;
40221 wxString *arg2 = 0 ;
40222 int result;
40223 void *argp1 = 0 ;
40224 int res1 = 0 ;
40225 bool temp2 = false ;
40226 PyObject * obj0 = 0 ;
40227 PyObject * obj1 = 0 ;
40228 char * kwnames[] = {
40229 (char *) "self",(char *) "item", NULL
40230 };
40231
40232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40234 if (!SWIG_IsOK(res1)) {
40235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40236 }
40237 arg1 = reinterpret_cast< wxMenu * >(argp1);
40238 {
40239 arg2 = wxString_in_helper(obj1);
40240 if (arg2 == NULL) SWIG_fail;
40241 temp2 = true;
40242 }
40243 {
40244 PyThreadState* __tstate = wxPyBeginAllowThreads();
40245 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40246 wxPyEndAllowThreads(__tstate);
40247 if (PyErr_Occurred()) SWIG_fail;
40248 }
40249 resultobj = SWIG_From_int(static_cast< int >(result));
40250 {
40251 if (temp2)
40252 delete arg2;
40253 }
40254 return resultobj;
40255 fail:
40256 {
40257 if (temp2)
40258 delete arg2;
40259 }
40260 return NULL;
40261 }
40262
40263
40264 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40265 PyObject *resultobj = 0;
40266 wxMenu *arg1 = (wxMenu *) 0 ;
40267 int arg2 ;
40268 wxMenuItem *result = 0 ;
40269 void *argp1 = 0 ;
40270 int res1 = 0 ;
40271 int val2 ;
40272 int ecode2 = 0 ;
40273 PyObject * obj0 = 0 ;
40274 PyObject * obj1 = 0 ;
40275 char * kwnames[] = {
40276 (char *) "self",(char *) "id", NULL
40277 };
40278
40279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40281 if (!SWIG_IsOK(res1)) {
40282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40283 }
40284 arg1 = reinterpret_cast< wxMenu * >(argp1);
40285 ecode2 = SWIG_AsVal_int(obj1, &val2);
40286 if (!SWIG_IsOK(ecode2)) {
40287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40288 }
40289 arg2 = static_cast< int >(val2);
40290 {
40291 PyThreadState* __tstate = wxPyBeginAllowThreads();
40292 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40293 wxPyEndAllowThreads(__tstate);
40294 if (PyErr_Occurred()) SWIG_fail;
40295 }
40296 {
40297 resultobj = wxPyMake_wxObject(result, (bool)0);
40298 }
40299 return resultobj;
40300 fail:
40301 return NULL;
40302 }
40303
40304
40305 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40306 PyObject *resultobj = 0;
40307 wxMenu *arg1 = (wxMenu *) 0 ;
40308 size_t arg2 ;
40309 wxMenuItem *result = 0 ;
40310 void *argp1 = 0 ;
40311 int res1 = 0 ;
40312 size_t val2 ;
40313 int ecode2 = 0 ;
40314 PyObject * obj0 = 0 ;
40315 PyObject * obj1 = 0 ;
40316 char * kwnames[] = {
40317 (char *) "self",(char *) "position", NULL
40318 };
40319
40320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",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_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40324 }
40325 arg1 = reinterpret_cast< wxMenu * >(argp1);
40326 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40327 if (!SWIG_IsOK(ecode2)) {
40328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40329 }
40330 arg2 = static_cast< size_t >(val2);
40331 {
40332 PyThreadState* __tstate = wxPyBeginAllowThreads();
40333 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40334 wxPyEndAllowThreads(__tstate);
40335 if (PyErr_Occurred()) SWIG_fail;
40336 }
40337 {
40338 resultobj = wxPyMake_wxObject(result, (bool)0);
40339 }
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40347 PyObject *resultobj = 0;
40348 wxMenu *arg1 = (wxMenu *) 0 ;
40349 int arg2 ;
40350 bool arg3 ;
40351 void *argp1 = 0 ;
40352 int res1 = 0 ;
40353 int val2 ;
40354 int ecode2 = 0 ;
40355 bool val3 ;
40356 int ecode3 = 0 ;
40357 PyObject * obj0 = 0 ;
40358 PyObject * obj1 = 0 ;
40359 PyObject * obj2 = 0 ;
40360 char * kwnames[] = {
40361 (char *) "self",(char *) "id",(char *) "enable", NULL
40362 };
40363
40364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40366 if (!SWIG_IsOK(res1)) {
40367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40368 }
40369 arg1 = reinterpret_cast< wxMenu * >(argp1);
40370 ecode2 = SWIG_AsVal_int(obj1, &val2);
40371 if (!SWIG_IsOK(ecode2)) {
40372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40373 }
40374 arg2 = static_cast< int >(val2);
40375 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40376 if (!SWIG_IsOK(ecode3)) {
40377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40378 }
40379 arg3 = static_cast< bool >(val3);
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 (arg1)->Enable(arg2,arg3);
40383 wxPyEndAllowThreads(__tstate);
40384 if (PyErr_Occurred()) SWIG_fail;
40385 }
40386 resultobj = SWIG_Py_Void();
40387 return resultobj;
40388 fail:
40389 return NULL;
40390 }
40391
40392
40393 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40394 PyObject *resultobj = 0;
40395 wxMenu *arg1 = (wxMenu *) 0 ;
40396 int arg2 ;
40397 bool result;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 int val2 ;
40401 int ecode2 = 0 ;
40402 PyObject * obj0 = 0 ;
40403 PyObject * obj1 = 0 ;
40404 char * kwnames[] = {
40405 (char *) "self",(char *) "id", NULL
40406 };
40407
40408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40410 if (!SWIG_IsOK(res1)) {
40411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40412 }
40413 arg1 = reinterpret_cast< wxMenu * >(argp1);
40414 ecode2 = SWIG_AsVal_int(obj1, &val2);
40415 if (!SWIG_IsOK(ecode2)) {
40416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40417 }
40418 arg2 = static_cast< int >(val2);
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40435 PyObject *resultobj = 0;
40436 wxMenu *arg1 = (wxMenu *) 0 ;
40437 int arg2 ;
40438 bool arg3 ;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 int val2 ;
40442 int ecode2 = 0 ;
40443 bool val3 ;
40444 int ecode3 = 0 ;
40445 PyObject * obj0 = 0 ;
40446 PyObject * obj1 = 0 ;
40447 PyObject * obj2 = 0 ;
40448 char * kwnames[] = {
40449 (char *) "self",(char *) "id",(char *) "check", NULL
40450 };
40451
40452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40454 if (!SWIG_IsOK(res1)) {
40455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40456 }
40457 arg1 = reinterpret_cast< wxMenu * >(argp1);
40458 ecode2 = SWIG_AsVal_int(obj1, &val2);
40459 if (!SWIG_IsOK(ecode2)) {
40460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40461 }
40462 arg2 = static_cast< int >(val2);
40463 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40464 if (!SWIG_IsOK(ecode3)) {
40465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40466 }
40467 arg3 = static_cast< bool >(val3);
40468 {
40469 PyThreadState* __tstate = wxPyBeginAllowThreads();
40470 (arg1)->Check(arg2,arg3);
40471 wxPyEndAllowThreads(__tstate);
40472 if (PyErr_Occurred()) SWIG_fail;
40473 }
40474 resultobj = SWIG_Py_Void();
40475 return resultobj;
40476 fail:
40477 return NULL;
40478 }
40479
40480
40481 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40482 PyObject *resultobj = 0;
40483 wxMenu *arg1 = (wxMenu *) 0 ;
40484 int arg2 ;
40485 bool result;
40486 void *argp1 = 0 ;
40487 int res1 = 0 ;
40488 int val2 ;
40489 int ecode2 = 0 ;
40490 PyObject * obj0 = 0 ;
40491 PyObject * obj1 = 0 ;
40492 char * kwnames[] = {
40493 (char *) "self",(char *) "id", NULL
40494 };
40495
40496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40498 if (!SWIG_IsOK(res1)) {
40499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40500 }
40501 arg1 = reinterpret_cast< wxMenu * >(argp1);
40502 ecode2 = SWIG_AsVal_int(obj1, &val2);
40503 if (!SWIG_IsOK(ecode2)) {
40504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40505 }
40506 arg2 = static_cast< int >(val2);
40507 {
40508 PyThreadState* __tstate = wxPyBeginAllowThreads();
40509 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 {
40514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40515 }
40516 return resultobj;
40517 fail:
40518 return NULL;
40519 }
40520
40521
40522 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40523 PyObject *resultobj = 0;
40524 wxMenu *arg1 = (wxMenu *) 0 ;
40525 int arg2 ;
40526 wxString *arg3 = 0 ;
40527 void *argp1 = 0 ;
40528 int res1 = 0 ;
40529 int val2 ;
40530 int ecode2 = 0 ;
40531 bool temp3 = false ;
40532 PyObject * obj0 = 0 ;
40533 PyObject * obj1 = 0 ;
40534 PyObject * obj2 = 0 ;
40535 char * kwnames[] = {
40536 (char *) "self",(char *) "id",(char *) "label", NULL
40537 };
40538
40539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40541 if (!SWIG_IsOK(res1)) {
40542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40543 }
40544 arg1 = reinterpret_cast< wxMenu * >(argp1);
40545 ecode2 = SWIG_AsVal_int(obj1, &val2);
40546 if (!SWIG_IsOK(ecode2)) {
40547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40548 }
40549 arg2 = static_cast< int >(val2);
40550 {
40551 arg3 = wxString_in_helper(obj2);
40552 if (arg3 == NULL) SWIG_fail;
40553 temp3 = true;
40554 }
40555 {
40556 PyThreadState* __tstate = wxPyBeginAllowThreads();
40557 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40558 wxPyEndAllowThreads(__tstate);
40559 if (PyErr_Occurred()) SWIG_fail;
40560 }
40561 resultobj = SWIG_Py_Void();
40562 {
40563 if (temp3)
40564 delete arg3;
40565 }
40566 return resultobj;
40567 fail:
40568 {
40569 if (temp3)
40570 delete arg3;
40571 }
40572 return NULL;
40573 }
40574
40575
40576 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40577 PyObject *resultobj = 0;
40578 wxMenu *arg1 = (wxMenu *) 0 ;
40579 int arg2 ;
40580 wxString result;
40581 void *argp1 = 0 ;
40582 int res1 = 0 ;
40583 int val2 ;
40584 int ecode2 = 0 ;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char * kwnames[] = {
40588 (char *) "self",(char *) "id", NULL
40589 };
40590
40591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40595 }
40596 arg1 = reinterpret_cast< wxMenu * >(argp1);
40597 ecode2 = SWIG_AsVal_int(obj1, &val2);
40598 if (!SWIG_IsOK(ecode2)) {
40599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40600 }
40601 arg2 = static_cast< int >(val2);
40602 {
40603 PyThreadState* __tstate = wxPyBeginAllowThreads();
40604 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 {
40609 #if wxUSE_UNICODE
40610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40611 #else
40612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40613 #endif
40614 }
40615 return resultobj;
40616 fail:
40617 return NULL;
40618 }
40619
40620
40621 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40622 PyObject *resultobj = 0;
40623 wxMenu *arg1 = (wxMenu *) 0 ;
40624 int arg2 ;
40625 wxString *arg3 = 0 ;
40626 void *argp1 = 0 ;
40627 int res1 = 0 ;
40628 int val2 ;
40629 int ecode2 = 0 ;
40630 bool temp3 = false ;
40631 PyObject * obj0 = 0 ;
40632 PyObject * obj1 = 0 ;
40633 PyObject * obj2 = 0 ;
40634 char * kwnames[] = {
40635 (char *) "self",(char *) "id",(char *) "helpString", NULL
40636 };
40637
40638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40642 }
40643 arg1 = reinterpret_cast< wxMenu * >(argp1);
40644 ecode2 = SWIG_AsVal_int(obj1, &val2);
40645 if (!SWIG_IsOK(ecode2)) {
40646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40647 }
40648 arg2 = static_cast< int >(val2);
40649 {
40650 arg3 = wxString_in_helper(obj2);
40651 if (arg3 == NULL) SWIG_fail;
40652 temp3 = true;
40653 }
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40657 wxPyEndAllowThreads(__tstate);
40658 if (PyErr_Occurred()) SWIG_fail;
40659 }
40660 resultobj = SWIG_Py_Void();
40661 {
40662 if (temp3)
40663 delete arg3;
40664 }
40665 return resultobj;
40666 fail:
40667 {
40668 if (temp3)
40669 delete arg3;
40670 }
40671 return NULL;
40672 }
40673
40674
40675 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40676 PyObject *resultobj = 0;
40677 wxMenu *arg1 = (wxMenu *) 0 ;
40678 int arg2 ;
40679 wxString result;
40680 void *argp1 = 0 ;
40681 int res1 = 0 ;
40682 int val2 ;
40683 int ecode2 = 0 ;
40684 PyObject * obj0 = 0 ;
40685 PyObject * obj1 = 0 ;
40686 char * kwnames[] = {
40687 (char *) "self",(char *) "id", NULL
40688 };
40689
40690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40692 if (!SWIG_IsOK(res1)) {
40693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40694 }
40695 arg1 = reinterpret_cast< wxMenu * >(argp1);
40696 ecode2 = SWIG_AsVal_int(obj1, &val2);
40697 if (!SWIG_IsOK(ecode2)) {
40698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40699 }
40700 arg2 = static_cast< int >(val2);
40701 {
40702 PyThreadState* __tstate = wxPyBeginAllowThreads();
40703 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40704 wxPyEndAllowThreads(__tstate);
40705 if (PyErr_Occurred()) SWIG_fail;
40706 }
40707 {
40708 #if wxUSE_UNICODE
40709 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40710 #else
40711 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40712 #endif
40713 }
40714 return resultobj;
40715 fail:
40716 return NULL;
40717 }
40718
40719
40720 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40721 PyObject *resultobj = 0;
40722 wxMenu *arg1 = (wxMenu *) 0 ;
40723 wxString *arg2 = 0 ;
40724 void *argp1 = 0 ;
40725 int res1 = 0 ;
40726 bool temp2 = false ;
40727 PyObject * obj0 = 0 ;
40728 PyObject * obj1 = 0 ;
40729 char * kwnames[] = {
40730 (char *) "self",(char *) "title", NULL
40731 };
40732
40733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40735 if (!SWIG_IsOK(res1)) {
40736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40737 }
40738 arg1 = reinterpret_cast< wxMenu * >(argp1);
40739 {
40740 arg2 = wxString_in_helper(obj1);
40741 if (arg2 == NULL) SWIG_fail;
40742 temp2 = true;
40743 }
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 (arg1)->SetTitle((wxString const &)*arg2);
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 resultobj = SWIG_Py_Void();
40751 {
40752 if (temp2)
40753 delete arg2;
40754 }
40755 return resultobj;
40756 fail:
40757 {
40758 if (temp2)
40759 delete arg2;
40760 }
40761 return NULL;
40762 }
40763
40764
40765 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40766 PyObject *resultobj = 0;
40767 wxMenu *arg1 = (wxMenu *) 0 ;
40768 wxString result;
40769 void *argp1 = 0 ;
40770 int res1 = 0 ;
40771 PyObject *swig_obj[1] ;
40772
40773 if (!args) SWIG_fail;
40774 swig_obj[0] = args;
40775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40776 if (!SWIG_IsOK(res1)) {
40777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40778 }
40779 arg1 = reinterpret_cast< wxMenu * >(argp1);
40780 {
40781 PyThreadState* __tstate = wxPyBeginAllowThreads();
40782 result = ((wxMenu const *)arg1)->GetTitle();
40783 wxPyEndAllowThreads(__tstate);
40784 if (PyErr_Occurred()) SWIG_fail;
40785 }
40786 {
40787 #if wxUSE_UNICODE
40788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40789 #else
40790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40791 #endif
40792 }
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40800 PyObject *resultobj = 0;
40801 wxMenu *arg1 = (wxMenu *) 0 ;
40802 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40803 void *argp1 = 0 ;
40804 int res1 = 0 ;
40805 void *argp2 = 0 ;
40806 int res2 = 0 ;
40807 PyObject * obj0 = 0 ;
40808 PyObject * obj1 = 0 ;
40809 char * kwnames[] = {
40810 (char *) "self",(char *) "handler", NULL
40811 };
40812
40813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40815 if (!SWIG_IsOK(res1)) {
40816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40817 }
40818 arg1 = reinterpret_cast< wxMenu * >(argp1);
40819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40820 if (!SWIG_IsOK(res2)) {
40821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40822 }
40823 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40824 {
40825 PyThreadState* __tstate = wxPyBeginAllowThreads();
40826 (arg1)->SetEventHandler(arg2);
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 resultobj = SWIG_Py_Void();
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40838 PyObject *resultobj = 0;
40839 wxMenu *arg1 = (wxMenu *) 0 ;
40840 wxEvtHandler *result = 0 ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 PyObject *swig_obj[1] ;
40844
40845 if (!args) SWIG_fail;
40846 swig_obj[0] = args;
40847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40848 if (!SWIG_IsOK(res1)) {
40849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40850 }
40851 arg1 = reinterpret_cast< wxMenu * >(argp1);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = wxPyMake_wxObject(result, 0);
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj = 0;
40869 wxMenu *arg1 = (wxMenu *) 0 ;
40870 wxWindow *arg2 = (wxWindow *) 0 ;
40871 void *argp1 = 0 ;
40872 int res1 = 0 ;
40873 void *argp2 = 0 ;
40874 int res2 = 0 ;
40875 PyObject * obj0 = 0 ;
40876 PyObject * obj1 = 0 ;
40877 char * kwnames[] = {
40878 (char *) "self",(char *) "win", NULL
40879 };
40880
40881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40883 if (!SWIG_IsOK(res1)) {
40884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40885 }
40886 arg1 = reinterpret_cast< wxMenu * >(argp1);
40887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40888 if (!SWIG_IsOK(res2)) {
40889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40890 }
40891 arg2 = reinterpret_cast< wxWindow * >(argp2);
40892 {
40893 PyThreadState* __tstate = wxPyBeginAllowThreads();
40894 (arg1)->SetInvokingWindow(arg2);
40895 wxPyEndAllowThreads(__tstate);
40896 if (PyErr_Occurred()) SWIG_fail;
40897 }
40898 resultobj = SWIG_Py_Void();
40899 return resultobj;
40900 fail:
40901 return NULL;
40902 }
40903
40904
40905 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40906 PyObject *resultobj = 0;
40907 wxMenu *arg1 = (wxMenu *) 0 ;
40908 wxWindow *result = 0 ;
40909 void *argp1 = 0 ;
40910 int res1 = 0 ;
40911 PyObject *swig_obj[1] ;
40912
40913 if (!args) SWIG_fail;
40914 swig_obj[0] = args;
40915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40916 if (!SWIG_IsOK(res1)) {
40917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40918 }
40919 arg1 = reinterpret_cast< wxMenu * >(argp1);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 {
40927 resultobj = wxPyMake_wxObject(result, 0);
40928 }
40929 return resultobj;
40930 fail:
40931 return NULL;
40932 }
40933
40934
40935 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40936 PyObject *resultobj = 0;
40937 wxMenu *arg1 = (wxMenu *) 0 ;
40938 long result;
40939 void *argp1 = 0 ;
40940 int res1 = 0 ;
40941 PyObject *swig_obj[1] ;
40942
40943 if (!args) SWIG_fail;
40944 swig_obj[0] = args;
40945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40946 if (!SWIG_IsOK(res1)) {
40947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40948 }
40949 arg1 = reinterpret_cast< wxMenu * >(argp1);
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 result = (long)((wxMenu const *)arg1)->GetStyle();
40953 wxPyEndAllowThreads(__tstate);
40954 if (PyErr_Occurred()) SWIG_fail;
40955 }
40956 resultobj = SWIG_From_long(static_cast< long >(result));
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40964 PyObject *resultobj = 0;
40965 wxMenu *arg1 = (wxMenu *) 0 ;
40966 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40967 void *argp1 = 0 ;
40968 int res1 = 0 ;
40969 void *argp2 = 0 ;
40970 int res2 = 0 ;
40971 PyObject * obj0 = 0 ;
40972 PyObject * obj1 = 0 ;
40973 char * kwnames[] = {
40974 (char *) "self",(char *) "source", NULL
40975 };
40976
40977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40979 if (!SWIG_IsOK(res1)) {
40980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40981 }
40982 arg1 = reinterpret_cast< wxMenu * >(argp1);
40983 if (obj1) {
40984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40985 if (!SWIG_IsOK(res2)) {
40986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40987 }
40988 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40989 }
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 (arg1)->UpdateUI(arg2);
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 resultobj = SWIG_Py_Void();
40997 return resultobj;
40998 fail:
40999 return NULL;
41000 }
41001
41002
41003 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41004 PyObject *resultobj = 0;
41005 wxMenu *arg1 = (wxMenu *) 0 ;
41006 wxMenuBar *result = 0 ;
41007 void *argp1 = 0 ;
41008 int res1 = 0 ;
41009 PyObject *swig_obj[1] ;
41010
41011 if (!args) SWIG_fail;
41012 swig_obj[0] = args;
41013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41014 if (!SWIG_IsOK(res1)) {
41015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41016 }
41017 arg1 = reinterpret_cast< wxMenu * >(argp1);
41018 {
41019 PyThreadState* __tstate = wxPyBeginAllowThreads();
41020 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41021 wxPyEndAllowThreads(__tstate);
41022 if (PyErr_Occurred()) SWIG_fail;
41023 }
41024 {
41025 resultobj = wxPyMake_wxObject(result, (bool)0);
41026 }
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj = 0;
41035 wxMenu *arg1 = (wxMenu *) 0 ;
41036 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41037 void *argp1 = 0 ;
41038 int res1 = 0 ;
41039 void *argp2 = 0 ;
41040 int res2 = 0 ;
41041 PyObject * obj0 = 0 ;
41042 PyObject * obj1 = 0 ;
41043 char * kwnames[] = {
41044 (char *) "self",(char *) "menubar", NULL
41045 };
41046
41047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41049 if (!SWIG_IsOK(res1)) {
41050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41051 }
41052 arg1 = reinterpret_cast< wxMenu * >(argp1);
41053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41054 if (!SWIG_IsOK(res2)) {
41055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41056 }
41057 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41058 {
41059 PyThreadState* __tstate = wxPyBeginAllowThreads();
41060 (arg1)->Attach(arg2);
41061 wxPyEndAllowThreads(__tstate);
41062 if (PyErr_Occurred()) SWIG_fail;
41063 }
41064 resultobj = SWIG_Py_Void();
41065 return resultobj;
41066 fail:
41067 return NULL;
41068 }
41069
41070
41071 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41072 PyObject *resultobj = 0;
41073 wxMenu *arg1 = (wxMenu *) 0 ;
41074 void *argp1 = 0 ;
41075 int res1 = 0 ;
41076 PyObject *swig_obj[1] ;
41077
41078 if (!args) SWIG_fail;
41079 swig_obj[0] = args;
41080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenu * >(argp1);
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 (arg1)->Detach();
41088 wxPyEndAllowThreads(__tstate);
41089 if (PyErr_Occurred()) SWIG_fail;
41090 }
41091 resultobj = SWIG_Py_Void();
41092 return resultobj;
41093 fail:
41094 return NULL;
41095 }
41096
41097
41098 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41099 PyObject *resultobj = 0;
41100 wxMenu *arg1 = (wxMenu *) 0 ;
41101 bool result;
41102 void *argp1 = 0 ;
41103 int res1 = 0 ;
41104 PyObject *swig_obj[1] ;
41105
41106 if (!args) SWIG_fail;
41107 swig_obj[0] = args;
41108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41109 if (!SWIG_IsOK(res1)) {
41110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41111 }
41112 arg1 = reinterpret_cast< wxMenu * >(argp1);
41113 {
41114 PyThreadState* __tstate = wxPyBeginAllowThreads();
41115 result = (bool)((wxMenu const *)arg1)->IsAttached();
41116 wxPyEndAllowThreads(__tstate);
41117 if (PyErr_Occurred()) SWIG_fail;
41118 }
41119 {
41120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41121 }
41122 return resultobj;
41123 fail:
41124 return NULL;
41125 }
41126
41127
41128 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41129 PyObject *resultobj = 0;
41130 wxMenu *arg1 = (wxMenu *) 0 ;
41131 wxMenu *arg2 = (wxMenu *) 0 ;
41132 void *argp1 = 0 ;
41133 int res1 = 0 ;
41134 void *argp2 = 0 ;
41135 int res2 = 0 ;
41136 PyObject * obj0 = 0 ;
41137 PyObject * obj1 = 0 ;
41138 char * kwnames[] = {
41139 (char *) "self",(char *) "parent", NULL
41140 };
41141
41142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41144 if (!SWIG_IsOK(res1)) {
41145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41146 }
41147 arg1 = reinterpret_cast< wxMenu * >(argp1);
41148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41149 if (!SWIG_IsOK(res2)) {
41150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41151 }
41152 arg2 = reinterpret_cast< wxMenu * >(argp2);
41153 {
41154 PyThreadState* __tstate = wxPyBeginAllowThreads();
41155 (arg1)->SetParent(arg2);
41156 wxPyEndAllowThreads(__tstate);
41157 if (PyErr_Occurred()) SWIG_fail;
41158 }
41159 resultobj = SWIG_Py_Void();
41160 return resultobj;
41161 fail:
41162 return NULL;
41163 }
41164
41165
41166 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41167 PyObject *resultobj = 0;
41168 wxMenu *arg1 = (wxMenu *) 0 ;
41169 wxMenu *result = 0 ;
41170 void *argp1 = 0 ;
41171 int res1 = 0 ;
41172 PyObject *swig_obj[1] ;
41173
41174 if (!args) SWIG_fail;
41175 swig_obj[0] = args;
41176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41177 if (!SWIG_IsOK(res1)) {
41178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41179 }
41180 arg1 = reinterpret_cast< wxMenu * >(argp1);
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41184 wxPyEndAllowThreads(__tstate);
41185 if (PyErr_Occurred()) SWIG_fail;
41186 }
41187 {
41188 resultobj = wxPyMake_wxObject(result, 0);
41189 }
41190 return resultobj;
41191 fail:
41192 return NULL;
41193 }
41194
41195
41196 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41197 PyObject *obj;
41198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41199 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41200 return SWIG_Py_Void();
41201 }
41202
41203 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41204 return SWIG_Python_InitShadowInstance(args);
41205 }
41206
41207 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj = 0;
41209 long arg1 = (long) 0 ;
41210 wxMenuBar *result = 0 ;
41211 long val1 ;
41212 int ecode1 = 0 ;
41213 PyObject * obj0 = 0 ;
41214 char * kwnames[] = {
41215 (char *) "style", NULL
41216 };
41217
41218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41219 if (obj0) {
41220 ecode1 = SWIG_AsVal_long(obj0, &val1);
41221 if (!SWIG_IsOK(ecode1)) {
41222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41223 }
41224 arg1 = static_cast< long >(val1);
41225 }
41226 {
41227 if (!wxPyCheckForApp()) SWIG_fail;
41228 PyThreadState* __tstate = wxPyBeginAllowThreads();
41229 result = (wxMenuBar *)new wxMenuBar(arg1);
41230 wxPyEndAllowThreads(__tstate);
41231 if (PyErr_Occurred()) SWIG_fail;
41232 }
41233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41234 return resultobj;
41235 fail:
41236 return NULL;
41237 }
41238
41239
41240 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41241 PyObject *resultobj = 0;
41242 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41243 wxMenu *arg2 = (wxMenu *) 0 ;
41244 wxString *arg3 = 0 ;
41245 bool result;
41246 void *argp1 = 0 ;
41247 int res1 = 0 ;
41248 void *argp2 = 0 ;
41249 int res2 = 0 ;
41250 bool temp3 = false ;
41251 PyObject * obj0 = 0 ;
41252 PyObject * obj1 = 0 ;
41253 PyObject * obj2 = 0 ;
41254 char * kwnames[] = {
41255 (char *) "self",(char *) "menu",(char *) "title", NULL
41256 };
41257
41258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41260 if (!SWIG_IsOK(res1)) {
41261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41262 }
41263 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41265 if (!SWIG_IsOK(res2)) {
41266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41267 }
41268 arg2 = reinterpret_cast< wxMenu * >(argp2);
41269 {
41270 arg3 = wxString_in_helper(obj2);
41271 if (arg3 == NULL) SWIG_fail;
41272 temp3 = true;
41273 }
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41277 wxPyEndAllowThreads(__tstate);
41278 if (PyErr_Occurred()) SWIG_fail;
41279 }
41280 {
41281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41282 }
41283 {
41284 if (temp3)
41285 delete arg3;
41286 }
41287 return resultobj;
41288 fail:
41289 {
41290 if (temp3)
41291 delete arg3;
41292 }
41293 return NULL;
41294 }
41295
41296
41297 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj = 0;
41299 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41300 size_t arg2 ;
41301 wxMenu *arg3 = (wxMenu *) 0 ;
41302 wxString *arg4 = 0 ;
41303 bool result;
41304 void *argp1 = 0 ;
41305 int res1 = 0 ;
41306 size_t val2 ;
41307 int ecode2 = 0 ;
41308 void *argp3 = 0 ;
41309 int res3 = 0 ;
41310 bool temp4 = false ;
41311 PyObject * obj0 = 0 ;
41312 PyObject * obj1 = 0 ;
41313 PyObject * obj2 = 0 ;
41314 PyObject * obj3 = 0 ;
41315 char * kwnames[] = {
41316 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41317 };
41318
41319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41321 if (!SWIG_IsOK(res1)) {
41322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41323 }
41324 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41325 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41326 if (!SWIG_IsOK(ecode2)) {
41327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41328 }
41329 arg2 = static_cast< size_t >(val2);
41330 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41331 if (!SWIG_IsOK(res3)) {
41332 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41333 }
41334 arg3 = reinterpret_cast< wxMenu * >(argp3);
41335 {
41336 arg4 = wxString_in_helper(obj3);
41337 if (arg4 == NULL) SWIG_fail;
41338 temp4 = true;
41339 }
41340 {
41341 PyThreadState* __tstate = wxPyBeginAllowThreads();
41342 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41343 wxPyEndAllowThreads(__tstate);
41344 if (PyErr_Occurred()) SWIG_fail;
41345 }
41346 {
41347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41348 }
41349 {
41350 if (temp4)
41351 delete arg4;
41352 }
41353 return resultobj;
41354 fail:
41355 {
41356 if (temp4)
41357 delete arg4;
41358 }
41359 return NULL;
41360 }
41361
41362
41363 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41364 PyObject *resultobj = 0;
41365 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41366 size_t result;
41367 void *argp1 = 0 ;
41368 int res1 = 0 ;
41369 PyObject *swig_obj[1] ;
41370
41371 if (!args) SWIG_fail;
41372 swig_obj[0] = args;
41373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41374 if (!SWIG_IsOK(res1)) {
41375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41376 }
41377 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41378 {
41379 PyThreadState* __tstate = wxPyBeginAllowThreads();
41380 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41385 return resultobj;
41386 fail:
41387 return NULL;
41388 }
41389
41390
41391 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj = 0;
41393 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41394 size_t arg2 ;
41395 wxMenu *result = 0 ;
41396 void *argp1 = 0 ;
41397 int res1 = 0 ;
41398 size_t val2 ;
41399 int ecode2 = 0 ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 char * kwnames[] = {
41403 (char *) "self",(char *) "pos", NULL
41404 };
41405
41406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41408 if (!SWIG_IsOK(res1)) {
41409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41410 }
41411 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41412 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41413 if (!SWIG_IsOK(ecode2)) {
41414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41415 }
41416 arg2 = static_cast< size_t >(val2);
41417 {
41418 PyThreadState* __tstate = wxPyBeginAllowThreads();
41419 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41420 wxPyEndAllowThreads(__tstate);
41421 if (PyErr_Occurred()) SWIG_fail;
41422 }
41423 {
41424 resultobj = wxPyMake_wxObject(result, 0);
41425 }
41426 return resultobj;
41427 fail:
41428 return NULL;
41429 }
41430
41431
41432 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41433 PyObject *resultobj = 0;
41434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41435 size_t arg2 ;
41436 wxMenu *arg3 = (wxMenu *) 0 ;
41437 wxString *arg4 = 0 ;
41438 wxMenu *result = 0 ;
41439 void *argp1 = 0 ;
41440 int res1 = 0 ;
41441 size_t val2 ;
41442 int ecode2 = 0 ;
41443 void *argp3 = 0 ;
41444 int res3 = 0 ;
41445 bool temp4 = false ;
41446 PyObject * obj0 = 0 ;
41447 PyObject * obj1 = 0 ;
41448 PyObject * obj2 = 0 ;
41449 PyObject * obj3 = 0 ;
41450 char * kwnames[] = {
41451 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41452 };
41453
41454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41456 if (!SWIG_IsOK(res1)) {
41457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41458 }
41459 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41460 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41461 if (!SWIG_IsOK(ecode2)) {
41462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41463 }
41464 arg2 = static_cast< size_t >(val2);
41465 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41466 if (!SWIG_IsOK(res3)) {
41467 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41468 }
41469 arg3 = reinterpret_cast< wxMenu * >(argp3);
41470 {
41471 arg4 = wxString_in_helper(obj3);
41472 if (arg4 == NULL) SWIG_fail;
41473 temp4 = true;
41474 }
41475 {
41476 PyThreadState* __tstate = wxPyBeginAllowThreads();
41477 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41478 wxPyEndAllowThreads(__tstate);
41479 if (PyErr_Occurred()) SWIG_fail;
41480 }
41481 {
41482 resultobj = wxPyMake_wxObject(result, 0);
41483 }
41484 {
41485 if (temp4)
41486 delete arg4;
41487 }
41488 return resultobj;
41489 fail:
41490 {
41491 if (temp4)
41492 delete arg4;
41493 }
41494 return NULL;
41495 }
41496
41497
41498 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41499 PyObject *resultobj = 0;
41500 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41501 size_t arg2 ;
41502 wxMenu *result = 0 ;
41503 void *argp1 = 0 ;
41504 int res1 = 0 ;
41505 size_t val2 ;
41506 int ecode2 = 0 ;
41507 PyObject * obj0 = 0 ;
41508 PyObject * obj1 = 0 ;
41509 char * kwnames[] = {
41510 (char *) "self",(char *) "pos", NULL
41511 };
41512
41513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41515 if (!SWIG_IsOK(res1)) {
41516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41517 }
41518 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41519 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41520 if (!SWIG_IsOK(ecode2)) {
41521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41522 }
41523 arg2 = static_cast< size_t >(val2);
41524 {
41525 PyThreadState* __tstate = wxPyBeginAllowThreads();
41526 result = (wxMenu *)(arg1)->Remove(arg2);
41527 wxPyEndAllowThreads(__tstate);
41528 if (PyErr_Occurred()) SWIG_fail;
41529 }
41530 {
41531 resultobj = wxPyMake_wxObject(result, 0);
41532 }
41533 return resultobj;
41534 fail:
41535 return NULL;
41536 }
41537
41538
41539 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41540 PyObject *resultobj = 0;
41541 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41542 size_t arg2 ;
41543 bool arg3 ;
41544 void *argp1 = 0 ;
41545 int res1 = 0 ;
41546 size_t val2 ;
41547 int ecode2 = 0 ;
41548 bool val3 ;
41549 int ecode3 = 0 ;
41550 PyObject * obj0 = 0 ;
41551 PyObject * obj1 = 0 ;
41552 PyObject * obj2 = 0 ;
41553 char * kwnames[] = {
41554 (char *) "self",(char *) "pos",(char *) "enable", NULL
41555 };
41556
41557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41559 if (!SWIG_IsOK(res1)) {
41560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41561 }
41562 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41563 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41564 if (!SWIG_IsOK(ecode2)) {
41565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41566 }
41567 arg2 = static_cast< size_t >(val2);
41568 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41569 if (!SWIG_IsOK(ecode3)) {
41570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41571 }
41572 arg3 = static_cast< bool >(val3);
41573 {
41574 PyThreadState* __tstate = wxPyBeginAllowThreads();
41575 (arg1)->EnableTop(arg2,arg3);
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 resultobj = SWIG_Py_Void();
41580 return resultobj;
41581 fail:
41582 return NULL;
41583 }
41584
41585
41586 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41587 PyObject *resultobj = 0;
41588 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41589 size_t arg2 ;
41590 bool result;
41591 void *argp1 = 0 ;
41592 int res1 = 0 ;
41593 size_t val2 ;
41594 int ecode2 = 0 ;
41595 PyObject * obj0 = 0 ;
41596 PyObject * obj1 = 0 ;
41597 char * kwnames[] = {
41598 (char *) "self",(char *) "pos", NULL
41599 };
41600
41601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41603 if (!SWIG_IsOK(res1)) {
41604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41605 }
41606 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41607 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41608 if (!SWIG_IsOK(ecode2)) {
41609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41610 }
41611 arg2 = static_cast< size_t >(val2);
41612 {
41613 PyThreadState* __tstate = wxPyBeginAllowThreads();
41614 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41615 wxPyEndAllowThreads(__tstate);
41616 if (PyErr_Occurred()) SWIG_fail;
41617 }
41618 {
41619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41620 }
41621 return resultobj;
41622 fail:
41623 return NULL;
41624 }
41625
41626
41627 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41628 PyObject *resultobj = 0;
41629 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41630 size_t arg2 ;
41631 wxString *arg3 = 0 ;
41632 void *argp1 = 0 ;
41633 int res1 = 0 ;
41634 size_t val2 ;
41635 int ecode2 = 0 ;
41636 bool temp3 = false ;
41637 PyObject * obj0 = 0 ;
41638 PyObject * obj1 = 0 ;
41639 PyObject * obj2 = 0 ;
41640 char * kwnames[] = {
41641 (char *) "self",(char *) "pos",(char *) "label", NULL
41642 };
41643
41644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41646 if (!SWIG_IsOK(res1)) {
41647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41648 }
41649 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41650 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41651 if (!SWIG_IsOK(ecode2)) {
41652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41653 }
41654 arg2 = static_cast< size_t >(val2);
41655 {
41656 arg3 = wxString_in_helper(obj2);
41657 if (arg3 == NULL) SWIG_fail;
41658 temp3 = true;
41659 }
41660 {
41661 PyThreadState* __tstate = wxPyBeginAllowThreads();
41662 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 resultobj = SWIG_Py_Void();
41667 {
41668 if (temp3)
41669 delete arg3;
41670 }
41671 return resultobj;
41672 fail:
41673 {
41674 if (temp3)
41675 delete arg3;
41676 }
41677 return NULL;
41678 }
41679
41680
41681 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41682 PyObject *resultobj = 0;
41683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41684 size_t arg2 ;
41685 wxString result;
41686 void *argp1 = 0 ;
41687 int res1 = 0 ;
41688 size_t val2 ;
41689 int ecode2 = 0 ;
41690 PyObject * obj0 = 0 ;
41691 PyObject * obj1 = 0 ;
41692 char * kwnames[] = {
41693 (char *) "self",(char *) "pos", NULL
41694 };
41695
41696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41698 if (!SWIG_IsOK(res1)) {
41699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41700 }
41701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41702 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41703 if (!SWIG_IsOK(ecode2)) {
41704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41705 }
41706 arg2 = static_cast< size_t >(val2);
41707 {
41708 PyThreadState* __tstate = wxPyBeginAllowThreads();
41709 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41710 wxPyEndAllowThreads(__tstate);
41711 if (PyErr_Occurred()) SWIG_fail;
41712 }
41713 {
41714 #if wxUSE_UNICODE
41715 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41716 #else
41717 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41718 #endif
41719 }
41720 return resultobj;
41721 fail:
41722 return NULL;
41723 }
41724
41725
41726 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41727 PyObject *resultobj = 0;
41728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41729 wxString *arg2 = 0 ;
41730 wxString *arg3 = 0 ;
41731 int result;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 bool temp2 = false ;
41735 bool temp3 = false ;
41736 PyObject * obj0 = 0 ;
41737 PyObject * obj1 = 0 ;
41738 PyObject * obj2 = 0 ;
41739 char * kwnames[] = {
41740 (char *) "self",(char *) "menu",(char *) "item", NULL
41741 };
41742
41743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41745 if (!SWIG_IsOK(res1)) {
41746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41747 }
41748 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41749 {
41750 arg2 = wxString_in_helper(obj1);
41751 if (arg2 == NULL) SWIG_fail;
41752 temp2 = true;
41753 }
41754 {
41755 arg3 = wxString_in_helper(obj2);
41756 if (arg3 == NULL) SWIG_fail;
41757 temp3 = true;
41758 }
41759 {
41760 PyThreadState* __tstate = wxPyBeginAllowThreads();
41761 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 resultobj = SWIG_From_int(static_cast< int >(result));
41766 {
41767 if (temp2)
41768 delete arg2;
41769 }
41770 {
41771 if (temp3)
41772 delete arg3;
41773 }
41774 return resultobj;
41775 fail:
41776 {
41777 if (temp2)
41778 delete arg2;
41779 }
41780 {
41781 if (temp3)
41782 delete arg3;
41783 }
41784 return NULL;
41785 }
41786
41787
41788 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41789 PyObject *resultobj = 0;
41790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41791 int arg2 ;
41792 wxMenuItem *result = 0 ;
41793 void *argp1 = 0 ;
41794 int res1 = 0 ;
41795 int val2 ;
41796 int ecode2 = 0 ;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799 char * kwnames[] = {
41800 (char *) "self",(char *) "id", NULL
41801 };
41802
41803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41805 if (!SWIG_IsOK(res1)) {
41806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41807 }
41808 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41809 ecode2 = SWIG_AsVal_int(obj1, &val2);
41810 if (!SWIG_IsOK(ecode2)) {
41811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41812 }
41813 arg2 = static_cast< int >(val2);
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 {
41821 resultobj = wxPyMake_wxObject(result, (bool)0);
41822 }
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj = 0;
41831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41832 wxString *arg2 = 0 ;
41833 int result;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 bool temp2 = false ;
41837 PyObject * obj0 = 0 ;
41838 PyObject * obj1 = 0 ;
41839 char * kwnames[] = {
41840 (char *) "self",(char *) "title", NULL
41841 };
41842
41843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41845 if (!SWIG_IsOK(res1)) {
41846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41847 }
41848 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41849 {
41850 arg2 = wxString_in_helper(obj1);
41851 if (arg2 == NULL) SWIG_fail;
41852 temp2 = true;
41853 }
41854 {
41855 PyThreadState* __tstate = wxPyBeginAllowThreads();
41856 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41857 wxPyEndAllowThreads(__tstate);
41858 if (PyErr_Occurred()) SWIG_fail;
41859 }
41860 resultobj = SWIG_From_int(static_cast< int >(result));
41861 {
41862 if (temp2)
41863 delete arg2;
41864 }
41865 return resultobj;
41866 fail:
41867 {
41868 if (temp2)
41869 delete arg2;
41870 }
41871 return NULL;
41872 }
41873
41874
41875 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41876 PyObject *resultobj = 0;
41877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41878 int arg2 ;
41879 bool arg3 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 int val2 ;
41883 int ecode2 = 0 ;
41884 bool val3 ;
41885 int ecode3 = 0 ;
41886 PyObject * obj0 = 0 ;
41887 PyObject * obj1 = 0 ;
41888 PyObject * obj2 = 0 ;
41889 char * kwnames[] = {
41890 (char *) "self",(char *) "id",(char *) "enable", NULL
41891 };
41892
41893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41895 if (!SWIG_IsOK(res1)) {
41896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41897 }
41898 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41899 ecode2 = SWIG_AsVal_int(obj1, &val2);
41900 if (!SWIG_IsOK(ecode2)) {
41901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41902 }
41903 arg2 = static_cast< int >(val2);
41904 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41905 if (!SWIG_IsOK(ecode3)) {
41906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41907 }
41908 arg3 = static_cast< bool >(val3);
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 (arg1)->Enable(arg2,arg3);
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 resultobj = SWIG_Py_Void();
41916 return resultobj;
41917 fail:
41918 return NULL;
41919 }
41920
41921
41922 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41923 PyObject *resultobj = 0;
41924 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41925 int arg2 ;
41926 bool arg3 ;
41927 void *argp1 = 0 ;
41928 int res1 = 0 ;
41929 int val2 ;
41930 int ecode2 = 0 ;
41931 bool val3 ;
41932 int ecode3 = 0 ;
41933 PyObject * obj0 = 0 ;
41934 PyObject * obj1 = 0 ;
41935 PyObject * obj2 = 0 ;
41936 char * kwnames[] = {
41937 (char *) "self",(char *) "id",(char *) "check", NULL
41938 };
41939
41940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41942 if (!SWIG_IsOK(res1)) {
41943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41944 }
41945 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41946 ecode2 = SWIG_AsVal_int(obj1, &val2);
41947 if (!SWIG_IsOK(ecode2)) {
41948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41949 }
41950 arg2 = static_cast< int >(val2);
41951 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41952 if (!SWIG_IsOK(ecode3)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41954 }
41955 arg3 = static_cast< bool >(val3);
41956 {
41957 PyThreadState* __tstate = wxPyBeginAllowThreads();
41958 (arg1)->Check(arg2,arg3);
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 resultobj = SWIG_Py_Void();
41963 return resultobj;
41964 fail:
41965 return NULL;
41966 }
41967
41968
41969 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj = 0;
41971 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41972 int arg2 ;
41973 bool result;
41974 void *argp1 = 0 ;
41975 int res1 = 0 ;
41976 int val2 ;
41977 int ecode2 = 0 ;
41978 PyObject * obj0 = 0 ;
41979 PyObject * obj1 = 0 ;
41980 char * kwnames[] = {
41981 (char *) "self",(char *) "id", NULL
41982 };
41983
41984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41986 if (!SWIG_IsOK(res1)) {
41987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41988 }
41989 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41990 ecode2 = SWIG_AsVal_int(obj1, &val2);
41991 if (!SWIG_IsOK(ecode2)) {
41992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41993 }
41994 arg2 = static_cast< int >(val2);
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41998 wxPyEndAllowThreads(__tstate);
41999 if (PyErr_Occurred()) SWIG_fail;
42000 }
42001 {
42002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42003 }
42004 return resultobj;
42005 fail:
42006 return NULL;
42007 }
42008
42009
42010 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42011 PyObject *resultobj = 0;
42012 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42013 int arg2 ;
42014 bool result;
42015 void *argp1 = 0 ;
42016 int res1 = 0 ;
42017 int val2 ;
42018 int ecode2 = 0 ;
42019 PyObject * obj0 = 0 ;
42020 PyObject * obj1 = 0 ;
42021 char * kwnames[] = {
42022 (char *) "self",(char *) "id", NULL
42023 };
42024
42025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42027 if (!SWIG_IsOK(res1)) {
42028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42029 }
42030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42031 ecode2 = SWIG_AsVal_int(obj1, &val2);
42032 if (!SWIG_IsOK(ecode2)) {
42033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42034 }
42035 arg2 = static_cast< int >(val2);
42036 {
42037 PyThreadState* __tstate = wxPyBeginAllowThreads();
42038 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42039 wxPyEndAllowThreads(__tstate);
42040 if (PyErr_Occurred()) SWIG_fail;
42041 }
42042 {
42043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42044 }
42045 return resultobj;
42046 fail:
42047 return NULL;
42048 }
42049
42050
42051 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42052 PyObject *resultobj = 0;
42053 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42054 int arg2 ;
42055 wxString *arg3 = 0 ;
42056 void *argp1 = 0 ;
42057 int res1 = 0 ;
42058 int val2 ;
42059 int ecode2 = 0 ;
42060 bool temp3 = false ;
42061 PyObject * obj0 = 0 ;
42062 PyObject * obj1 = 0 ;
42063 PyObject * obj2 = 0 ;
42064 char * kwnames[] = {
42065 (char *) "self",(char *) "id",(char *) "label", NULL
42066 };
42067
42068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42070 if (!SWIG_IsOK(res1)) {
42071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42072 }
42073 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42074 ecode2 = SWIG_AsVal_int(obj1, &val2);
42075 if (!SWIG_IsOK(ecode2)) {
42076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42077 }
42078 arg2 = static_cast< int >(val2);
42079 {
42080 arg3 = wxString_in_helper(obj2);
42081 if (arg3 == NULL) SWIG_fail;
42082 temp3 = true;
42083 }
42084 {
42085 PyThreadState* __tstate = wxPyBeginAllowThreads();
42086 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42087 wxPyEndAllowThreads(__tstate);
42088 if (PyErr_Occurred()) SWIG_fail;
42089 }
42090 resultobj = SWIG_Py_Void();
42091 {
42092 if (temp3)
42093 delete arg3;
42094 }
42095 return resultobj;
42096 fail:
42097 {
42098 if (temp3)
42099 delete arg3;
42100 }
42101 return NULL;
42102 }
42103
42104
42105 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj = 0;
42107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42108 int arg2 ;
42109 wxString result;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 int val2 ;
42113 int ecode2 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 char * kwnames[] = {
42117 (char *) "self",(char *) "id", NULL
42118 };
42119
42120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42122 if (!SWIG_IsOK(res1)) {
42123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42124 }
42125 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42126 ecode2 = SWIG_AsVal_int(obj1, &val2);
42127 if (!SWIG_IsOK(ecode2)) {
42128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42129 }
42130 arg2 = static_cast< int >(val2);
42131 {
42132 PyThreadState* __tstate = wxPyBeginAllowThreads();
42133 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42134 wxPyEndAllowThreads(__tstate);
42135 if (PyErr_Occurred()) SWIG_fail;
42136 }
42137 {
42138 #if wxUSE_UNICODE
42139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42140 #else
42141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42142 #endif
42143 }
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42151 PyObject *resultobj = 0;
42152 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42153 int arg2 ;
42154 wxString *arg3 = 0 ;
42155 void *argp1 = 0 ;
42156 int res1 = 0 ;
42157 int val2 ;
42158 int ecode2 = 0 ;
42159 bool temp3 = false ;
42160 PyObject * obj0 = 0 ;
42161 PyObject * obj1 = 0 ;
42162 PyObject * obj2 = 0 ;
42163 char * kwnames[] = {
42164 (char *) "self",(char *) "id",(char *) "helpString", NULL
42165 };
42166
42167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42169 if (!SWIG_IsOK(res1)) {
42170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42171 }
42172 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42173 ecode2 = SWIG_AsVal_int(obj1, &val2);
42174 if (!SWIG_IsOK(ecode2)) {
42175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42176 }
42177 arg2 = static_cast< int >(val2);
42178 {
42179 arg3 = wxString_in_helper(obj2);
42180 if (arg3 == NULL) SWIG_fail;
42181 temp3 = true;
42182 }
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42186 wxPyEndAllowThreads(__tstate);
42187 if (PyErr_Occurred()) SWIG_fail;
42188 }
42189 resultobj = SWIG_Py_Void();
42190 {
42191 if (temp3)
42192 delete arg3;
42193 }
42194 return resultobj;
42195 fail:
42196 {
42197 if (temp3)
42198 delete arg3;
42199 }
42200 return NULL;
42201 }
42202
42203
42204 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42205 PyObject *resultobj = 0;
42206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42207 int arg2 ;
42208 wxString result;
42209 void *argp1 = 0 ;
42210 int res1 = 0 ;
42211 int val2 ;
42212 int ecode2 = 0 ;
42213 PyObject * obj0 = 0 ;
42214 PyObject * obj1 = 0 ;
42215 char * kwnames[] = {
42216 (char *) "self",(char *) "id", NULL
42217 };
42218
42219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42221 if (!SWIG_IsOK(res1)) {
42222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42223 }
42224 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42225 ecode2 = SWIG_AsVal_int(obj1, &val2);
42226 if (!SWIG_IsOK(ecode2)) {
42227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42228 }
42229 arg2 = static_cast< int >(val2);
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 {
42237 #if wxUSE_UNICODE
42238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42239 #else
42240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42241 #endif
42242 }
42243 return resultobj;
42244 fail:
42245 return NULL;
42246 }
42247
42248
42249 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42250 PyObject *resultobj = 0;
42251 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42252 wxFrame *result = 0 ;
42253 void *argp1 = 0 ;
42254 int res1 = 0 ;
42255 PyObject *swig_obj[1] ;
42256
42257 if (!args) SWIG_fail;
42258 swig_obj[0] = args;
42259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42260 if (!SWIG_IsOK(res1)) {
42261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42262 }
42263 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42264 {
42265 PyThreadState* __tstate = wxPyBeginAllowThreads();
42266 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 {
42271 resultobj = wxPyMake_wxObject(result, (bool)0);
42272 }
42273 return resultobj;
42274 fail:
42275 return NULL;
42276 }
42277
42278
42279 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42280 PyObject *resultobj = 0;
42281 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42282 bool result;
42283 void *argp1 = 0 ;
42284 int res1 = 0 ;
42285 PyObject *swig_obj[1] ;
42286
42287 if (!args) SWIG_fail;
42288 swig_obj[0] = args;
42289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42290 if (!SWIG_IsOK(res1)) {
42291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42292 }
42293 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42294 {
42295 PyThreadState* __tstate = wxPyBeginAllowThreads();
42296 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42297 wxPyEndAllowThreads(__tstate);
42298 if (PyErr_Occurred()) SWIG_fail;
42299 }
42300 {
42301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42302 }
42303 return resultobj;
42304 fail:
42305 return NULL;
42306 }
42307
42308
42309 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42310 PyObject *resultobj = 0;
42311 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42312 wxFrame *arg2 = (wxFrame *) 0 ;
42313 void *argp1 = 0 ;
42314 int res1 = 0 ;
42315 void *argp2 = 0 ;
42316 int res2 = 0 ;
42317 PyObject * obj0 = 0 ;
42318 PyObject * obj1 = 0 ;
42319 char * kwnames[] = {
42320 (char *) "self",(char *) "frame", NULL
42321 };
42322
42323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42325 if (!SWIG_IsOK(res1)) {
42326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42327 }
42328 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42329 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42330 if (!SWIG_IsOK(res2)) {
42331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42332 }
42333 arg2 = reinterpret_cast< wxFrame * >(argp2);
42334 {
42335 PyThreadState* __tstate = wxPyBeginAllowThreads();
42336 (arg1)->Attach(arg2);
42337 wxPyEndAllowThreads(__tstate);
42338 if (PyErr_Occurred()) SWIG_fail;
42339 }
42340 resultobj = SWIG_Py_Void();
42341 return resultobj;
42342 fail:
42343 return NULL;
42344 }
42345
42346
42347 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42348 PyObject *resultobj = 0;
42349 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42350 void *argp1 = 0 ;
42351 int res1 = 0 ;
42352 PyObject *swig_obj[1] ;
42353
42354 if (!args) SWIG_fail;
42355 swig_obj[0] = args;
42356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42357 if (!SWIG_IsOK(res1)) {
42358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42359 }
42360 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42361 {
42362 PyThreadState* __tstate = wxPyBeginAllowThreads();
42363 (arg1)->Detach();
42364 wxPyEndAllowThreads(__tstate);
42365 if (PyErr_Occurred()) SWIG_fail;
42366 }
42367 resultobj = SWIG_Py_Void();
42368 return resultobj;
42369 fail:
42370 return NULL;
42371 }
42372
42373
42374 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42375 PyObject *resultobj = 0;
42376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42377 void *argp1 = 0 ;
42378 int res1 = 0 ;
42379 PyObject *swig_obj[1] ;
42380
42381 if (!args) SWIG_fail;
42382 swig_obj[0] = args;
42383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42384 if (!SWIG_IsOK(res1)) {
42385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42386 }
42387 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42388 {
42389 PyThreadState* __tstate = wxPyBeginAllowThreads();
42390 (arg1)->UpdateMenus();
42391 wxPyEndAllowThreads(__tstate);
42392 if (PyErr_Occurred()) SWIG_fail;
42393 }
42394 resultobj = SWIG_Py_Void();
42395 return resultobj;
42396 fail:
42397 return NULL;
42398 }
42399
42400
42401 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42402 PyObject *resultobj = 0;
42403 bool arg1 ;
42404 bool val1 ;
42405 int ecode1 = 0 ;
42406 PyObject * obj0 = 0 ;
42407 char * kwnames[] = {
42408 (char *) "enable", NULL
42409 };
42410
42411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42412 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42413 if (!SWIG_IsOK(ecode1)) {
42414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42415 }
42416 arg1 = static_cast< bool >(val1);
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 wxMenuBar::SetAutoWindowMenu(arg1);
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 resultobj = SWIG_Py_Void();
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42431 PyObject *resultobj = 0;
42432 bool result;
42433
42434 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42435 {
42436 PyThreadState* __tstate = wxPyBeginAllowThreads();
42437 result = (bool)wxMenuBar::GetAutoWindowMenu();
42438 wxPyEndAllowThreads(__tstate);
42439 if (PyErr_Occurred()) SWIG_fail;
42440 }
42441 {
42442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42443 }
42444 return resultobj;
42445 fail:
42446 return NULL;
42447 }
42448
42449
42450 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42451 PyObject *obj;
42452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42453 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42454 return SWIG_Py_Void();
42455 }
42456
42457 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42458 return SWIG_Python_InitShadowInstance(args);
42459 }
42460
42461 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42462 PyObject *resultobj = 0;
42463 wxMenu *arg1 = (wxMenu *) NULL ;
42464 int arg2 = (int) wxID_ANY ;
42465 wxString const &arg3_defvalue = wxPyEmptyString ;
42466 wxString *arg3 = (wxString *) &arg3_defvalue ;
42467 wxString const &arg4_defvalue = wxPyEmptyString ;
42468 wxString *arg4 = (wxString *) &arg4_defvalue ;
42469 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42470 wxMenu *arg6 = (wxMenu *) NULL ;
42471 wxMenuItem *result = 0 ;
42472 void *argp1 = 0 ;
42473 int res1 = 0 ;
42474 int val2 ;
42475 int ecode2 = 0 ;
42476 bool temp3 = false ;
42477 bool temp4 = false ;
42478 int val5 ;
42479 int ecode5 = 0 ;
42480 void *argp6 = 0 ;
42481 int res6 = 0 ;
42482 PyObject * obj0 = 0 ;
42483 PyObject * obj1 = 0 ;
42484 PyObject * obj2 = 0 ;
42485 PyObject * obj3 = 0 ;
42486 PyObject * obj4 = 0 ;
42487 PyObject * obj5 = 0 ;
42488 char * kwnames[] = {
42489 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42490 };
42491
42492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42493 if (obj0) {
42494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42495 if (!SWIG_IsOK(res1)) {
42496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42497 }
42498 arg1 = reinterpret_cast< wxMenu * >(argp1);
42499 }
42500 if (obj1) {
42501 ecode2 = SWIG_AsVal_int(obj1, &val2);
42502 if (!SWIG_IsOK(ecode2)) {
42503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42504 }
42505 arg2 = static_cast< int >(val2);
42506 }
42507 if (obj2) {
42508 {
42509 arg3 = wxString_in_helper(obj2);
42510 if (arg3 == NULL) SWIG_fail;
42511 temp3 = true;
42512 }
42513 }
42514 if (obj3) {
42515 {
42516 arg4 = wxString_in_helper(obj3);
42517 if (arg4 == NULL) SWIG_fail;
42518 temp4 = true;
42519 }
42520 }
42521 if (obj4) {
42522 ecode5 = SWIG_AsVal_int(obj4, &val5);
42523 if (!SWIG_IsOK(ecode5)) {
42524 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42525 }
42526 arg5 = static_cast< wxItemKind >(val5);
42527 }
42528 if (obj5) {
42529 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42530 if (!SWIG_IsOK(res6)) {
42531 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42532 }
42533 arg6 = reinterpret_cast< wxMenu * >(argp6);
42534 }
42535 {
42536 PyThreadState* __tstate = wxPyBeginAllowThreads();
42537 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 {
42542 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42543 }
42544 {
42545 if (temp3)
42546 delete arg3;
42547 }
42548 {
42549 if (temp4)
42550 delete arg4;
42551 }
42552 return resultobj;
42553 fail:
42554 {
42555 if (temp3)
42556 delete arg3;
42557 }
42558 {
42559 if (temp4)
42560 delete arg4;
42561 }
42562 return NULL;
42563 }
42564
42565
42566 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42567 PyObject *resultobj = 0;
42568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42569 void *argp1 = 0 ;
42570 int res1 = 0 ;
42571 PyObject *swig_obj[1] ;
42572
42573 if (!args) SWIG_fail;
42574 swig_obj[0] = args;
42575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42576 if (!SWIG_IsOK(res1)) {
42577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42578 }
42579 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42580 {
42581 PyThreadState* __tstate = wxPyBeginAllowThreads();
42582 delete arg1;
42583
42584 wxPyEndAllowThreads(__tstate);
42585 if (PyErr_Occurred()) SWIG_fail;
42586 }
42587 resultobj = SWIG_Py_Void();
42588 return resultobj;
42589 fail:
42590 return NULL;
42591 }
42592
42593
42594 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42595 PyObject *resultobj = 0;
42596 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42597 wxMenu *result = 0 ;
42598 void *argp1 = 0 ;
42599 int res1 = 0 ;
42600 PyObject *swig_obj[1] ;
42601
42602 if (!args) SWIG_fail;
42603 swig_obj[0] = args;
42604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42605 if (!SWIG_IsOK(res1)) {
42606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42607 }
42608 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42609 {
42610 PyThreadState* __tstate = wxPyBeginAllowThreads();
42611 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 {
42616 resultobj = wxPyMake_wxObject(result, 0);
42617 }
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42625 PyObject *resultobj = 0;
42626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42627 wxMenu *arg2 = (wxMenu *) 0 ;
42628 void *argp1 = 0 ;
42629 int res1 = 0 ;
42630 void *argp2 = 0 ;
42631 int res2 = 0 ;
42632 PyObject * obj0 = 0 ;
42633 PyObject * obj1 = 0 ;
42634 char * kwnames[] = {
42635 (char *) "self",(char *) "menu", NULL
42636 };
42637
42638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42644 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42645 if (!SWIG_IsOK(res2)) {
42646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42647 }
42648 arg2 = reinterpret_cast< wxMenu * >(argp2);
42649 {
42650 PyThreadState* __tstate = wxPyBeginAllowThreads();
42651 (arg1)->SetMenu(arg2);
42652 wxPyEndAllowThreads(__tstate);
42653 if (PyErr_Occurred()) SWIG_fail;
42654 }
42655 resultobj = SWIG_Py_Void();
42656 return resultobj;
42657 fail:
42658 return NULL;
42659 }
42660
42661
42662 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42663 PyObject *resultobj = 0;
42664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42665 int arg2 ;
42666 void *argp1 = 0 ;
42667 int res1 = 0 ;
42668 int val2 ;
42669 int ecode2 = 0 ;
42670 PyObject * obj0 = 0 ;
42671 PyObject * obj1 = 0 ;
42672 char * kwnames[] = {
42673 (char *) "self",(char *) "id", NULL
42674 };
42675
42676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42678 if (!SWIG_IsOK(res1)) {
42679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42680 }
42681 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42682 ecode2 = SWIG_AsVal_int(obj1, &val2);
42683 if (!SWIG_IsOK(ecode2)) {
42684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42685 }
42686 arg2 = static_cast< int >(val2);
42687 {
42688 PyThreadState* __tstate = wxPyBeginAllowThreads();
42689 (arg1)->SetId(arg2);
42690 wxPyEndAllowThreads(__tstate);
42691 if (PyErr_Occurred()) SWIG_fail;
42692 }
42693 resultobj = SWIG_Py_Void();
42694 return resultobj;
42695 fail:
42696 return NULL;
42697 }
42698
42699
42700 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42701 PyObject *resultobj = 0;
42702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42703 int result;
42704 void *argp1 = 0 ;
42705 int res1 = 0 ;
42706 PyObject *swig_obj[1] ;
42707
42708 if (!args) SWIG_fail;
42709 swig_obj[0] = args;
42710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42711 if (!SWIG_IsOK(res1)) {
42712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42713 }
42714 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42715 {
42716 PyThreadState* __tstate = wxPyBeginAllowThreads();
42717 result = (int)((wxMenuItem const *)arg1)->GetId();
42718 wxPyEndAllowThreads(__tstate);
42719 if (PyErr_Occurred()) SWIG_fail;
42720 }
42721 resultobj = SWIG_From_int(static_cast< int >(result));
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42729 PyObject *resultobj = 0;
42730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42731 bool result;
42732 void *argp1 = 0 ;
42733 int res1 = 0 ;
42734 PyObject *swig_obj[1] ;
42735
42736 if (!args) SWIG_fail;
42737 swig_obj[0] = args;
42738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 {
42744 PyThreadState* __tstate = wxPyBeginAllowThreads();
42745 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 {
42750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42751 }
42752 return resultobj;
42753 fail:
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42759 PyObject *resultobj = 0;
42760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42761 wxString *arg2 = 0 ;
42762 void *argp1 = 0 ;
42763 int res1 = 0 ;
42764 bool temp2 = false ;
42765 PyObject * obj0 = 0 ;
42766 PyObject * obj1 = 0 ;
42767 char * kwnames[] = {
42768 (char *) "self",(char *) "str", NULL
42769 };
42770
42771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42773 if (!SWIG_IsOK(res1)) {
42774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42775 }
42776 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42777 {
42778 arg2 = wxString_in_helper(obj1);
42779 if (arg2 == NULL) SWIG_fail;
42780 temp2 = true;
42781 }
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 (arg1)->SetText((wxString const &)*arg2);
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 resultobj = SWIG_Py_Void();
42789 {
42790 if (temp2)
42791 delete arg2;
42792 }
42793 return resultobj;
42794 fail:
42795 {
42796 if (temp2)
42797 delete arg2;
42798 }
42799 return NULL;
42800 }
42801
42802
42803 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42804 PyObject *resultobj = 0;
42805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42806 wxString result;
42807 void *argp1 = 0 ;
42808 int res1 = 0 ;
42809 PyObject *swig_obj[1] ;
42810
42811 if (!args) SWIG_fail;
42812 swig_obj[0] = args;
42813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42814 if (!SWIG_IsOK(res1)) {
42815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42816 }
42817 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42818 {
42819 PyThreadState* __tstate = wxPyBeginAllowThreads();
42820 result = ((wxMenuItem const *)arg1)->GetLabel();
42821 wxPyEndAllowThreads(__tstate);
42822 if (PyErr_Occurred()) SWIG_fail;
42823 }
42824 {
42825 #if wxUSE_UNICODE
42826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42827 #else
42828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42829 #endif
42830 }
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42838 PyObject *resultobj = 0;
42839 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42840 wxString *result = 0 ;
42841 void *argp1 = 0 ;
42842 int res1 = 0 ;
42843 PyObject *swig_obj[1] ;
42844
42845 if (!args) SWIG_fail;
42846 swig_obj[0] = args;
42847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 {
42855 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42856 result = (wxString *) &_result_ref;
42857 }
42858 wxPyEndAllowThreads(__tstate);
42859 if (PyErr_Occurred()) SWIG_fail;
42860 }
42861 {
42862 #if wxUSE_UNICODE
42863 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42864 #else
42865 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42866 #endif
42867 }
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42875 PyObject *resultobj = 0;
42876 wxString *arg1 = 0 ;
42877 wxString result;
42878 bool temp1 = false ;
42879 PyObject * obj0 = 0 ;
42880 char * kwnames[] = {
42881 (char *) "text", NULL
42882 };
42883
42884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42885 {
42886 arg1 = wxString_in_helper(obj0);
42887 if (arg1 == NULL) SWIG_fail;
42888 temp1 = true;
42889 }
42890 {
42891 PyThreadState* __tstate = wxPyBeginAllowThreads();
42892 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42893 wxPyEndAllowThreads(__tstate);
42894 if (PyErr_Occurred()) SWIG_fail;
42895 }
42896 {
42897 #if wxUSE_UNICODE
42898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42899 #else
42900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42901 #endif
42902 }
42903 {
42904 if (temp1)
42905 delete arg1;
42906 }
42907 return resultobj;
42908 fail:
42909 {
42910 if (temp1)
42911 delete arg1;
42912 }
42913 return NULL;
42914 }
42915
42916
42917 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42918 PyObject *resultobj = 0;
42919 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42920 wxItemKind result;
42921 void *argp1 = 0 ;
42922 int res1 = 0 ;
42923 PyObject *swig_obj[1] ;
42924
42925 if (!args) SWIG_fail;
42926 swig_obj[0] = args;
42927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42928 if (!SWIG_IsOK(res1)) {
42929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42930 }
42931 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42932 {
42933 PyThreadState* __tstate = wxPyBeginAllowThreads();
42934 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42935 wxPyEndAllowThreads(__tstate);
42936 if (PyErr_Occurred()) SWIG_fail;
42937 }
42938 resultobj = SWIG_From_int(static_cast< int >(result));
42939 return resultobj;
42940 fail:
42941 return NULL;
42942 }
42943
42944
42945 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42946 PyObject *resultobj = 0;
42947 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42948 wxItemKind arg2 ;
42949 void *argp1 = 0 ;
42950 int res1 = 0 ;
42951 int val2 ;
42952 int ecode2 = 0 ;
42953 PyObject * obj0 = 0 ;
42954 PyObject * obj1 = 0 ;
42955 char * kwnames[] = {
42956 (char *) "self",(char *) "kind", NULL
42957 };
42958
42959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42961 if (!SWIG_IsOK(res1)) {
42962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42963 }
42964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42965 ecode2 = SWIG_AsVal_int(obj1, &val2);
42966 if (!SWIG_IsOK(ecode2)) {
42967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42968 }
42969 arg2 = static_cast< wxItemKind >(val2);
42970 {
42971 PyThreadState* __tstate = wxPyBeginAllowThreads();
42972 (arg1)->SetKind(arg2);
42973 wxPyEndAllowThreads(__tstate);
42974 if (PyErr_Occurred()) SWIG_fail;
42975 }
42976 resultobj = SWIG_Py_Void();
42977 return resultobj;
42978 fail:
42979 return NULL;
42980 }
42981
42982
42983 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42984 PyObject *resultobj = 0;
42985 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42986 bool arg2 ;
42987 void *argp1 = 0 ;
42988 int res1 = 0 ;
42989 bool val2 ;
42990 int ecode2 = 0 ;
42991 PyObject * obj0 = 0 ;
42992 PyObject * obj1 = 0 ;
42993 char * kwnames[] = {
42994 (char *) "self",(char *) "checkable", NULL
42995 };
42996
42997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42999 if (!SWIG_IsOK(res1)) {
43000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43001 }
43002 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43004 if (!SWIG_IsOK(ecode2)) {
43005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43006 }
43007 arg2 = static_cast< bool >(val2);
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 (arg1)->SetCheckable(arg2);
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 resultobj = SWIG_Py_Void();
43015 return resultobj;
43016 fail:
43017 return NULL;
43018 }
43019
43020
43021 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43022 PyObject *resultobj = 0;
43023 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43024 bool result;
43025 void *argp1 = 0 ;
43026 int res1 = 0 ;
43027 PyObject *swig_obj[1] ;
43028
43029 if (!args) SWIG_fail;
43030 swig_obj[0] = args;
43031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43032 if (!SWIG_IsOK(res1)) {
43033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43034 }
43035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43036 {
43037 PyThreadState* __tstate = wxPyBeginAllowThreads();
43038 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43039 wxPyEndAllowThreads(__tstate);
43040 if (PyErr_Occurred()) SWIG_fail;
43041 }
43042 {
43043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43044 }
43045 return resultobj;
43046 fail:
43047 return NULL;
43048 }
43049
43050
43051 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43052 PyObject *resultobj = 0;
43053 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43054 bool result;
43055 void *argp1 = 0 ;
43056 int res1 = 0 ;
43057 PyObject *swig_obj[1] ;
43058
43059 if (!args) SWIG_fail;
43060 swig_obj[0] = args;
43061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43062 if (!SWIG_IsOK(res1)) {
43063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43064 }
43065 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43066 {
43067 PyThreadState* __tstate = wxPyBeginAllowThreads();
43068 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43069 wxPyEndAllowThreads(__tstate);
43070 if (PyErr_Occurred()) SWIG_fail;
43071 }
43072 {
43073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43074 }
43075 return resultobj;
43076 fail:
43077 return NULL;
43078 }
43079
43080
43081 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43082 PyObject *resultobj = 0;
43083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43084 wxMenu *arg2 = (wxMenu *) 0 ;
43085 void *argp1 = 0 ;
43086 int res1 = 0 ;
43087 void *argp2 = 0 ;
43088 int res2 = 0 ;
43089 PyObject * obj0 = 0 ;
43090 PyObject * obj1 = 0 ;
43091 char * kwnames[] = {
43092 (char *) "self",(char *) "menu", NULL
43093 };
43094
43095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43097 if (!SWIG_IsOK(res1)) {
43098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43099 }
43100 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43102 if (!SWIG_IsOK(res2)) {
43103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43104 }
43105 arg2 = reinterpret_cast< wxMenu * >(argp2);
43106 {
43107 PyThreadState* __tstate = wxPyBeginAllowThreads();
43108 (arg1)->SetSubMenu(arg2);
43109 wxPyEndAllowThreads(__tstate);
43110 if (PyErr_Occurred()) SWIG_fail;
43111 }
43112 resultobj = SWIG_Py_Void();
43113 return resultobj;
43114 fail:
43115 return NULL;
43116 }
43117
43118
43119 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43120 PyObject *resultobj = 0;
43121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43122 wxMenu *result = 0 ;
43123 void *argp1 = 0 ;
43124 int res1 = 0 ;
43125 PyObject *swig_obj[1] ;
43126
43127 if (!args) SWIG_fail;
43128 swig_obj[0] = args;
43129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43130 if (!SWIG_IsOK(res1)) {
43131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43132 }
43133 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43134 {
43135 PyThreadState* __tstate = wxPyBeginAllowThreads();
43136 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 {
43141 resultobj = wxPyMake_wxObject(result, 0);
43142 }
43143 return resultobj;
43144 fail:
43145 return NULL;
43146 }
43147
43148
43149 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43150 PyObject *resultobj = 0;
43151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43152 bool arg2 = (bool) true ;
43153 void *argp1 = 0 ;
43154 int res1 = 0 ;
43155 bool val2 ;
43156 int ecode2 = 0 ;
43157 PyObject * obj0 = 0 ;
43158 PyObject * obj1 = 0 ;
43159 char * kwnames[] = {
43160 (char *) "self",(char *) "enable", NULL
43161 };
43162
43163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43165 if (!SWIG_IsOK(res1)) {
43166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43167 }
43168 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43169 if (obj1) {
43170 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43171 if (!SWIG_IsOK(ecode2)) {
43172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43173 }
43174 arg2 = static_cast< bool >(val2);
43175 }
43176 {
43177 PyThreadState* __tstate = wxPyBeginAllowThreads();
43178 (arg1)->Enable(arg2);
43179 wxPyEndAllowThreads(__tstate);
43180 if (PyErr_Occurred()) SWIG_fail;
43181 }
43182 resultobj = SWIG_Py_Void();
43183 return resultobj;
43184 fail:
43185 return NULL;
43186 }
43187
43188
43189 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43190 PyObject *resultobj = 0;
43191 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43192 bool result;
43193 void *argp1 = 0 ;
43194 int res1 = 0 ;
43195 PyObject *swig_obj[1] ;
43196
43197 if (!args) SWIG_fail;
43198 swig_obj[0] = args;
43199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43200 if (!SWIG_IsOK(res1)) {
43201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43202 }
43203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43204 {
43205 PyThreadState* __tstate = wxPyBeginAllowThreads();
43206 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43207 wxPyEndAllowThreads(__tstate);
43208 if (PyErr_Occurred()) SWIG_fail;
43209 }
43210 {
43211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43212 }
43213 return resultobj;
43214 fail:
43215 return NULL;
43216 }
43217
43218
43219 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43220 PyObject *resultobj = 0;
43221 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43222 bool arg2 = (bool) true ;
43223 void *argp1 = 0 ;
43224 int res1 = 0 ;
43225 bool val2 ;
43226 int ecode2 = 0 ;
43227 PyObject * obj0 = 0 ;
43228 PyObject * obj1 = 0 ;
43229 char * kwnames[] = {
43230 (char *) "self",(char *) "check", NULL
43231 };
43232
43233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43235 if (!SWIG_IsOK(res1)) {
43236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43237 }
43238 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43239 if (obj1) {
43240 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43241 if (!SWIG_IsOK(ecode2)) {
43242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43243 }
43244 arg2 = static_cast< bool >(val2);
43245 }
43246 {
43247 PyThreadState* __tstate = wxPyBeginAllowThreads();
43248 (arg1)->Check(arg2);
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 resultobj = SWIG_Py_Void();
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43260 PyObject *resultobj = 0;
43261 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43262 bool result;
43263 void *argp1 = 0 ;
43264 int res1 = 0 ;
43265 PyObject *swig_obj[1] ;
43266
43267 if (!args) SWIG_fail;
43268 swig_obj[0] = args;
43269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43270 if (!SWIG_IsOK(res1)) {
43271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43272 }
43273 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 {
43281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43282 }
43283 return resultobj;
43284 fail:
43285 return NULL;
43286 }
43287
43288
43289 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43290 PyObject *resultobj = 0;
43291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43292 void *argp1 = 0 ;
43293 int res1 = 0 ;
43294 PyObject *swig_obj[1] ;
43295
43296 if (!args) SWIG_fail;
43297 swig_obj[0] = args;
43298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43299 if (!SWIG_IsOK(res1)) {
43300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43301 }
43302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43303 {
43304 PyThreadState* __tstate = wxPyBeginAllowThreads();
43305 (arg1)->Toggle();
43306 wxPyEndAllowThreads(__tstate);
43307 if (PyErr_Occurred()) SWIG_fail;
43308 }
43309 resultobj = SWIG_Py_Void();
43310 return resultobj;
43311 fail:
43312 return NULL;
43313 }
43314
43315
43316 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43317 PyObject *resultobj = 0;
43318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43319 wxString *arg2 = 0 ;
43320 void *argp1 = 0 ;
43321 int res1 = 0 ;
43322 bool temp2 = false ;
43323 PyObject * obj0 = 0 ;
43324 PyObject * obj1 = 0 ;
43325 char * kwnames[] = {
43326 (char *) "self",(char *) "str", NULL
43327 };
43328
43329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43331 if (!SWIG_IsOK(res1)) {
43332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43333 }
43334 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43335 {
43336 arg2 = wxString_in_helper(obj1);
43337 if (arg2 == NULL) SWIG_fail;
43338 temp2 = true;
43339 }
43340 {
43341 PyThreadState* __tstate = wxPyBeginAllowThreads();
43342 (arg1)->SetHelp((wxString const &)*arg2);
43343 wxPyEndAllowThreads(__tstate);
43344 if (PyErr_Occurred()) SWIG_fail;
43345 }
43346 resultobj = SWIG_Py_Void();
43347 {
43348 if (temp2)
43349 delete arg2;
43350 }
43351 return resultobj;
43352 fail:
43353 {
43354 if (temp2)
43355 delete arg2;
43356 }
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43362 PyObject *resultobj = 0;
43363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43364 wxString *result = 0 ;
43365 void *argp1 = 0 ;
43366 int res1 = 0 ;
43367 PyObject *swig_obj[1] ;
43368
43369 if (!args) SWIG_fail;
43370 swig_obj[0] = args;
43371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43372 if (!SWIG_IsOK(res1)) {
43373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43374 }
43375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 {
43379 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43380 result = (wxString *) &_result_ref;
43381 }
43382 wxPyEndAllowThreads(__tstate);
43383 if (PyErr_Occurred()) SWIG_fail;
43384 }
43385 {
43386 #if wxUSE_UNICODE
43387 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43388 #else
43389 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43390 #endif
43391 }
43392 return resultobj;
43393 fail:
43394 return NULL;
43395 }
43396
43397
43398 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43399 PyObject *resultobj = 0;
43400 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43401 wxAcceleratorEntry *result = 0 ;
43402 void *argp1 = 0 ;
43403 int res1 = 0 ;
43404 PyObject *swig_obj[1] ;
43405
43406 if (!args) SWIG_fail;
43407 swig_obj[0] = args;
43408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43409 if (!SWIG_IsOK(res1)) {
43410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43411 }
43412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43413 {
43414 PyThreadState* __tstate = wxPyBeginAllowThreads();
43415 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43420 return resultobj;
43421 fail:
43422 return NULL;
43423 }
43424
43425
43426 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43427 PyObject *resultobj = 0;
43428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43429 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43430 void *argp1 = 0 ;
43431 int res1 = 0 ;
43432 void *argp2 = 0 ;
43433 int res2 = 0 ;
43434 PyObject * obj0 = 0 ;
43435 PyObject * obj1 = 0 ;
43436 char * kwnames[] = {
43437 (char *) "self",(char *) "accel", NULL
43438 };
43439
43440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43442 if (!SWIG_IsOK(res1)) {
43443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43444 }
43445 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43447 if (!SWIG_IsOK(res2)) {
43448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43449 }
43450 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43451 {
43452 PyThreadState* __tstate = wxPyBeginAllowThreads();
43453 (arg1)->SetAccel(arg2);
43454 wxPyEndAllowThreads(__tstate);
43455 if (PyErr_Occurred()) SWIG_fail;
43456 }
43457 resultobj = SWIG_Py_Void();
43458 return resultobj;
43459 fail:
43460 return NULL;
43461 }
43462
43463
43464 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43465 PyObject *resultobj = 0;
43466 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43467 wxBitmap *arg2 = 0 ;
43468 void *argp1 = 0 ;
43469 int res1 = 0 ;
43470 void *argp2 = 0 ;
43471 int res2 = 0 ;
43472 PyObject * obj0 = 0 ;
43473 PyObject * obj1 = 0 ;
43474 char * kwnames[] = {
43475 (char *) "self",(char *) "bitmap", NULL
43476 };
43477
43478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res1)) {
43481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43482 }
43483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43484 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43485 if (!SWIG_IsOK(res2)) {
43486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43487 }
43488 if (!argp2) {
43489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43490 }
43491 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43495 wxPyEndAllowThreads(__tstate);
43496 if (PyErr_Occurred()) SWIG_fail;
43497 }
43498 resultobj = SWIG_Py_Void();
43499 return resultobj;
43500 fail:
43501 return NULL;
43502 }
43503
43504
43505 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43506 PyObject *resultobj = 0;
43507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43508 wxBitmap *result = 0 ;
43509 void *argp1 = 0 ;
43510 int res1 = 0 ;
43511 PyObject *swig_obj[1] ;
43512
43513 if (!args) SWIG_fail;
43514 swig_obj[0] = args;
43515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43520 {
43521 PyThreadState* __tstate = wxPyBeginAllowThreads();
43522 {
43523 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43524 result = (wxBitmap *) &_result_ref;
43525 }
43526 wxPyEndAllowThreads(__tstate);
43527 if (PyErr_Occurred()) SWIG_fail;
43528 }
43529 {
43530 wxBitmap* resultptr = new wxBitmap(*result);
43531 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43532 }
43533 return resultobj;
43534 fail:
43535 return NULL;
43536 }
43537
43538
43539 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43540 PyObject *resultobj = 0;
43541 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43542 wxFont *arg2 = 0 ;
43543 void *argp1 = 0 ;
43544 int res1 = 0 ;
43545 void *argp2 = 0 ;
43546 int res2 = 0 ;
43547 PyObject * obj0 = 0 ;
43548 PyObject * obj1 = 0 ;
43549 char * kwnames[] = {
43550 (char *) "self",(char *) "font", NULL
43551 };
43552
43553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43555 if (!SWIG_IsOK(res1)) {
43556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43557 }
43558 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43559 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43560 if (!SWIG_IsOK(res2)) {
43561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43562 }
43563 if (!argp2) {
43564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43565 }
43566 arg2 = reinterpret_cast< wxFont * >(argp2);
43567 {
43568 PyThreadState* __tstate = wxPyBeginAllowThreads();
43569 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43570 wxPyEndAllowThreads(__tstate);
43571 if (PyErr_Occurred()) SWIG_fail;
43572 }
43573 resultobj = SWIG_Py_Void();
43574 return resultobj;
43575 fail:
43576 return NULL;
43577 }
43578
43579
43580 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43581 PyObject *resultobj = 0;
43582 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43583 wxFont result;
43584 void *argp1 = 0 ;
43585 int res1 = 0 ;
43586 PyObject *swig_obj[1] ;
43587
43588 if (!args) SWIG_fail;
43589 swig_obj[0] = args;
43590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43591 if (!SWIG_IsOK(res1)) {
43592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43593 }
43594 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43595 {
43596 PyThreadState* __tstate = wxPyBeginAllowThreads();
43597 result = wxMenuItem_GetFont(arg1);
43598 wxPyEndAllowThreads(__tstate);
43599 if (PyErr_Occurred()) SWIG_fail;
43600 }
43601 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43602 return resultobj;
43603 fail:
43604 return NULL;
43605 }
43606
43607
43608 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43609 PyObject *resultobj = 0;
43610 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43611 wxColour *arg2 = 0 ;
43612 void *argp1 = 0 ;
43613 int res1 = 0 ;
43614 wxColour temp2 ;
43615 PyObject * obj0 = 0 ;
43616 PyObject * obj1 = 0 ;
43617 char * kwnames[] = {
43618 (char *) "self",(char *) "colText", NULL
43619 };
43620
43621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43623 if (!SWIG_IsOK(res1)) {
43624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43625 }
43626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43627 {
43628 arg2 = &temp2;
43629 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43630 }
43631 {
43632 PyThreadState* __tstate = wxPyBeginAllowThreads();
43633 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43634 wxPyEndAllowThreads(__tstate);
43635 if (PyErr_Occurred()) SWIG_fail;
43636 }
43637 resultobj = SWIG_Py_Void();
43638 return resultobj;
43639 fail:
43640 return NULL;
43641 }
43642
43643
43644 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43645 PyObject *resultobj = 0;
43646 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43647 wxColour result;
43648 void *argp1 = 0 ;
43649 int res1 = 0 ;
43650 PyObject *swig_obj[1] ;
43651
43652 if (!args) SWIG_fail;
43653 swig_obj[0] = args;
43654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43655 if (!SWIG_IsOK(res1)) {
43656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43657 }
43658 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43659 {
43660 PyThreadState* __tstate = wxPyBeginAllowThreads();
43661 result = wxMenuItem_GetTextColour(arg1);
43662 wxPyEndAllowThreads(__tstate);
43663 if (PyErr_Occurred()) SWIG_fail;
43664 }
43665 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43666 return resultobj;
43667 fail:
43668 return NULL;
43669 }
43670
43671
43672 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43673 PyObject *resultobj = 0;
43674 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43675 wxColour *arg2 = 0 ;
43676 void *argp1 = 0 ;
43677 int res1 = 0 ;
43678 wxColour temp2 ;
43679 PyObject * obj0 = 0 ;
43680 PyObject * obj1 = 0 ;
43681 char * kwnames[] = {
43682 (char *) "self",(char *) "colBack", NULL
43683 };
43684
43685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43687 if (!SWIG_IsOK(res1)) {
43688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43689 }
43690 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43691 {
43692 arg2 = &temp2;
43693 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43694 }
43695 {
43696 PyThreadState* __tstate = wxPyBeginAllowThreads();
43697 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43698 wxPyEndAllowThreads(__tstate);
43699 if (PyErr_Occurred()) SWIG_fail;
43700 }
43701 resultobj = SWIG_Py_Void();
43702 return resultobj;
43703 fail:
43704 return NULL;
43705 }
43706
43707
43708 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43709 PyObject *resultobj = 0;
43710 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43711 wxColour result;
43712 void *argp1 = 0 ;
43713 int res1 = 0 ;
43714 PyObject *swig_obj[1] ;
43715
43716 if (!args) SWIG_fail;
43717 swig_obj[0] = args;
43718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43719 if (!SWIG_IsOK(res1)) {
43720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43721 }
43722 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43723 {
43724 PyThreadState* __tstate = wxPyBeginAllowThreads();
43725 result = wxMenuItem_GetBackgroundColour(arg1);
43726 wxPyEndAllowThreads(__tstate);
43727 if (PyErr_Occurred()) SWIG_fail;
43728 }
43729 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43730 return resultobj;
43731 fail:
43732 return NULL;
43733 }
43734
43735
43736 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43737 PyObject *resultobj = 0;
43738 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43739 wxBitmap *arg2 = 0 ;
43740 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43741 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43742 void *argp1 = 0 ;
43743 int res1 = 0 ;
43744 void *argp2 = 0 ;
43745 int res2 = 0 ;
43746 void *argp3 = 0 ;
43747 int res3 = 0 ;
43748 PyObject * obj0 = 0 ;
43749 PyObject * obj1 = 0 ;
43750 PyObject * obj2 = 0 ;
43751 char * kwnames[] = {
43752 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43753 };
43754
43755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43757 if (!SWIG_IsOK(res1)) {
43758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43759 }
43760 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43762 if (!SWIG_IsOK(res2)) {
43763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43764 }
43765 if (!argp2) {
43766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43767 }
43768 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43769 if (obj2) {
43770 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43771 if (!SWIG_IsOK(res3)) {
43772 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43773 }
43774 if (!argp3) {
43775 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43776 }
43777 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43778 }
43779 {
43780 PyThreadState* __tstate = wxPyBeginAllowThreads();
43781 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43782 wxPyEndAllowThreads(__tstate);
43783 if (PyErr_Occurred()) SWIG_fail;
43784 }
43785 resultobj = SWIG_Py_Void();
43786 return resultobj;
43787 fail:
43788 return NULL;
43789 }
43790
43791
43792 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43793 PyObject *resultobj = 0;
43794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43795 wxBitmap *arg2 = 0 ;
43796 void *argp1 = 0 ;
43797 int res1 = 0 ;
43798 void *argp2 = 0 ;
43799 int res2 = 0 ;
43800 PyObject * obj0 = 0 ;
43801 PyObject * obj1 = 0 ;
43802 char * kwnames[] = {
43803 (char *) "self",(char *) "bmpDisabled", NULL
43804 };
43805
43806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43808 if (!SWIG_IsOK(res1)) {
43809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43810 }
43811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43813 if (!SWIG_IsOK(res2)) {
43814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43815 }
43816 if (!argp2) {
43817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43818 }
43819 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43820 {
43821 PyThreadState* __tstate = wxPyBeginAllowThreads();
43822 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43823 wxPyEndAllowThreads(__tstate);
43824 if (PyErr_Occurred()) SWIG_fail;
43825 }
43826 resultobj = SWIG_Py_Void();
43827 return resultobj;
43828 fail:
43829 return NULL;
43830 }
43831
43832
43833 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43834 PyObject *resultobj = 0;
43835 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43836 wxBitmap *result = 0 ;
43837 void *argp1 = 0 ;
43838 int res1 = 0 ;
43839 PyObject *swig_obj[1] ;
43840
43841 if (!args) SWIG_fail;
43842 swig_obj[0] = args;
43843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43844 if (!SWIG_IsOK(res1)) {
43845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43846 }
43847 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43848 {
43849 PyThreadState* __tstate = wxPyBeginAllowThreads();
43850 {
43851 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43852 result = (wxBitmap *) &_result_ref;
43853 }
43854 wxPyEndAllowThreads(__tstate);
43855 if (PyErr_Occurred()) SWIG_fail;
43856 }
43857 {
43858 wxBitmap* resultptr = new wxBitmap(*result);
43859 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43860 }
43861 return resultobj;
43862 fail:
43863 return NULL;
43864 }
43865
43866
43867 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43868 PyObject *resultobj = 0;
43869 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43870 int arg2 ;
43871 void *argp1 = 0 ;
43872 int res1 = 0 ;
43873 int val2 ;
43874 int ecode2 = 0 ;
43875 PyObject * obj0 = 0 ;
43876 PyObject * obj1 = 0 ;
43877 char * kwnames[] = {
43878 (char *) "self",(char *) "nWidth", NULL
43879 };
43880
43881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43883 if (!SWIG_IsOK(res1)) {
43884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43885 }
43886 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43887 ecode2 = SWIG_AsVal_int(obj1, &val2);
43888 if (!SWIG_IsOK(ecode2)) {
43889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43890 }
43891 arg2 = static_cast< int >(val2);
43892 {
43893 PyThreadState* __tstate = wxPyBeginAllowThreads();
43894 wxMenuItem_SetMarginWidth(arg1,arg2);
43895 wxPyEndAllowThreads(__tstate);
43896 if (PyErr_Occurred()) SWIG_fail;
43897 }
43898 resultobj = SWIG_Py_Void();
43899 return resultobj;
43900 fail:
43901 return NULL;
43902 }
43903
43904
43905 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43906 PyObject *resultobj = 0;
43907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43908 int result;
43909 void *argp1 = 0 ;
43910 int res1 = 0 ;
43911 PyObject *swig_obj[1] ;
43912
43913 if (!args) SWIG_fail;
43914 swig_obj[0] = args;
43915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43916 if (!SWIG_IsOK(res1)) {
43917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43918 }
43919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43920 {
43921 PyThreadState* __tstate = wxPyBeginAllowThreads();
43922 result = (int)wxMenuItem_GetMarginWidth(arg1);
43923 wxPyEndAllowThreads(__tstate);
43924 if (PyErr_Occurred()) SWIG_fail;
43925 }
43926 resultobj = SWIG_From_int(static_cast< int >(result));
43927 return resultobj;
43928 fail:
43929 return NULL;
43930 }
43931
43932
43933 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43934 PyObject *resultobj = 0;
43935 int result;
43936
43937 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43938 {
43939 PyThreadState* __tstate = wxPyBeginAllowThreads();
43940 result = (int)wxMenuItem_GetDefaultMarginWidth();
43941 wxPyEndAllowThreads(__tstate);
43942 if (PyErr_Occurred()) SWIG_fail;
43943 }
43944 resultobj = SWIG_From_int(static_cast< int >(result));
43945 return resultobj;
43946 fail:
43947 return NULL;
43948 }
43949
43950
43951 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43952 PyObject *resultobj = 0;
43953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43954 bool result;
43955 void *argp1 = 0 ;
43956 int res1 = 0 ;
43957 PyObject *swig_obj[1] ;
43958
43959 if (!args) SWIG_fail;
43960 swig_obj[0] = args;
43961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43962 if (!SWIG_IsOK(res1)) {
43963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43964 }
43965 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43966 {
43967 PyThreadState* __tstate = wxPyBeginAllowThreads();
43968 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43969 wxPyEndAllowThreads(__tstate);
43970 if (PyErr_Occurred()) SWIG_fail;
43971 }
43972 {
43973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43974 }
43975 return resultobj;
43976 fail:
43977 return NULL;
43978 }
43979
43980
43981 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43982 PyObject *resultobj = 0;
43983 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43984 bool arg2 = (bool) true ;
43985 void *argp1 = 0 ;
43986 int res1 = 0 ;
43987 bool val2 ;
43988 int ecode2 = 0 ;
43989 PyObject * obj0 = 0 ;
43990 PyObject * obj1 = 0 ;
43991 char * kwnames[] = {
43992 (char *) "self",(char *) "ownerDrawn", NULL
43993 };
43994
43995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43997 if (!SWIG_IsOK(res1)) {
43998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43999 }
44000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44001 if (obj1) {
44002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44003 if (!SWIG_IsOK(ecode2)) {
44004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44005 }
44006 arg2 = static_cast< bool >(val2);
44007 }
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 resultobj = SWIG_Py_Void();
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44022 PyObject *resultobj = 0;
44023 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44024 void *argp1 = 0 ;
44025 int res1 = 0 ;
44026 PyObject *swig_obj[1] ;
44027
44028 if (!args) SWIG_fail;
44029 swig_obj[0] = args;
44030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44031 if (!SWIG_IsOK(res1)) {
44032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44033 }
44034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 wxMenuItem_ResetOwnerDrawn(arg1);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 resultobj = SWIG_Py_Void();
44042 return resultobj;
44043 fail:
44044 return NULL;
44045 }
44046
44047
44048 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44049 PyObject *obj;
44050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44051 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44052 return SWIG_Py_Void();
44053 }
44054
44055 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44056 return SWIG_Python_InitShadowInstance(args);
44057 }
44058
44059 SWIGINTERN int ControlNameStr_set(PyObject *) {
44060 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44061 return 1;
44062 }
44063
44064
44065 SWIGINTERN PyObject *ControlNameStr_get(void) {
44066 PyObject *pyobj = 0;
44067
44068 {
44069 #if wxUSE_UNICODE
44070 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44071 #else
44072 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44073 #endif
44074 }
44075 return pyobj;
44076 }
44077
44078
44079 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44080 PyObject *resultobj = 0;
44081 wxWindow *arg1 = (wxWindow *) 0 ;
44082 int arg2 = (int) -1 ;
44083 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44084 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44085 wxSize const &arg4_defvalue = wxDefaultSize ;
44086 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44087 long arg5 = (long) 0 ;
44088 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44089 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44090 wxString const &arg7_defvalue = wxPyControlNameStr ;
44091 wxString *arg7 = (wxString *) &arg7_defvalue ;
44092 wxControl *result = 0 ;
44093 void *argp1 = 0 ;
44094 int res1 = 0 ;
44095 int val2 ;
44096 int ecode2 = 0 ;
44097 wxPoint temp3 ;
44098 wxSize temp4 ;
44099 long val5 ;
44100 int ecode5 = 0 ;
44101 void *argp6 = 0 ;
44102 int res6 = 0 ;
44103 bool temp7 = false ;
44104 PyObject * obj0 = 0 ;
44105 PyObject * obj1 = 0 ;
44106 PyObject * obj2 = 0 ;
44107 PyObject * obj3 = 0 ;
44108 PyObject * obj4 = 0 ;
44109 PyObject * obj5 = 0 ;
44110 PyObject * obj6 = 0 ;
44111 char * kwnames[] = {
44112 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44113 };
44114
44115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44119 }
44120 arg1 = reinterpret_cast< wxWindow * >(argp1);
44121 if (obj1) {
44122 ecode2 = SWIG_AsVal_int(obj1, &val2);
44123 if (!SWIG_IsOK(ecode2)) {
44124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44125 }
44126 arg2 = static_cast< int >(val2);
44127 }
44128 if (obj2) {
44129 {
44130 arg3 = &temp3;
44131 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44132 }
44133 }
44134 if (obj3) {
44135 {
44136 arg4 = &temp4;
44137 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44138 }
44139 }
44140 if (obj4) {
44141 ecode5 = SWIG_AsVal_long(obj4, &val5);
44142 if (!SWIG_IsOK(ecode5)) {
44143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44144 }
44145 arg5 = static_cast< long >(val5);
44146 }
44147 if (obj5) {
44148 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44149 if (!SWIG_IsOK(res6)) {
44150 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44151 }
44152 if (!argp6) {
44153 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44154 }
44155 arg6 = reinterpret_cast< wxValidator * >(argp6);
44156 }
44157 if (obj6) {
44158 {
44159 arg7 = wxString_in_helper(obj6);
44160 if (arg7 == NULL) SWIG_fail;
44161 temp7 = true;
44162 }
44163 }
44164 {
44165 if (!wxPyCheckForApp()) SWIG_fail;
44166 PyThreadState* __tstate = wxPyBeginAllowThreads();
44167 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44168 wxPyEndAllowThreads(__tstate);
44169 if (PyErr_Occurred()) SWIG_fail;
44170 }
44171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44172 {
44173 if (temp7)
44174 delete arg7;
44175 }
44176 return resultobj;
44177 fail:
44178 {
44179 if (temp7)
44180 delete arg7;
44181 }
44182 return NULL;
44183 }
44184
44185
44186 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44187 PyObject *resultobj = 0;
44188 wxControl *result = 0 ;
44189
44190 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44191 {
44192 if (!wxPyCheckForApp()) SWIG_fail;
44193 PyThreadState* __tstate = wxPyBeginAllowThreads();
44194 result = (wxControl *)new wxControl();
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44199 return resultobj;
44200 fail:
44201 return NULL;
44202 }
44203
44204
44205 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44206 PyObject *resultobj = 0;
44207 wxControl *arg1 = (wxControl *) 0 ;
44208 wxWindow *arg2 = (wxWindow *) 0 ;
44209 int arg3 = (int) -1 ;
44210 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44211 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44212 wxSize const &arg5_defvalue = wxDefaultSize ;
44213 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44214 long arg6 = (long) 0 ;
44215 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44216 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44217 wxString const &arg8_defvalue = wxPyControlNameStr ;
44218 wxString *arg8 = (wxString *) &arg8_defvalue ;
44219 bool result;
44220 void *argp1 = 0 ;
44221 int res1 = 0 ;
44222 void *argp2 = 0 ;
44223 int res2 = 0 ;
44224 int val3 ;
44225 int ecode3 = 0 ;
44226 wxPoint temp4 ;
44227 wxSize temp5 ;
44228 long val6 ;
44229 int ecode6 = 0 ;
44230 void *argp7 = 0 ;
44231 int res7 = 0 ;
44232 bool temp8 = false ;
44233 PyObject * obj0 = 0 ;
44234 PyObject * obj1 = 0 ;
44235 PyObject * obj2 = 0 ;
44236 PyObject * obj3 = 0 ;
44237 PyObject * obj4 = 0 ;
44238 PyObject * obj5 = 0 ;
44239 PyObject * obj6 = 0 ;
44240 PyObject * obj7 = 0 ;
44241 char * kwnames[] = {
44242 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44243 };
44244
44245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44247 if (!SWIG_IsOK(res1)) {
44248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44249 }
44250 arg1 = reinterpret_cast< wxControl * >(argp1);
44251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44252 if (!SWIG_IsOK(res2)) {
44253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44254 }
44255 arg2 = reinterpret_cast< wxWindow * >(argp2);
44256 if (obj2) {
44257 ecode3 = SWIG_AsVal_int(obj2, &val3);
44258 if (!SWIG_IsOK(ecode3)) {
44259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44260 }
44261 arg3 = static_cast< int >(val3);
44262 }
44263 if (obj3) {
44264 {
44265 arg4 = &temp4;
44266 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44267 }
44268 }
44269 if (obj4) {
44270 {
44271 arg5 = &temp5;
44272 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44273 }
44274 }
44275 if (obj5) {
44276 ecode6 = SWIG_AsVal_long(obj5, &val6);
44277 if (!SWIG_IsOK(ecode6)) {
44278 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44279 }
44280 arg6 = static_cast< long >(val6);
44281 }
44282 if (obj6) {
44283 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44284 if (!SWIG_IsOK(res7)) {
44285 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44286 }
44287 if (!argp7) {
44288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44289 }
44290 arg7 = reinterpret_cast< wxValidator * >(argp7);
44291 }
44292 if (obj7) {
44293 {
44294 arg8 = wxString_in_helper(obj7);
44295 if (arg8 == NULL) SWIG_fail;
44296 temp8 = true;
44297 }
44298 }
44299 {
44300 PyThreadState* __tstate = wxPyBeginAllowThreads();
44301 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44302 wxPyEndAllowThreads(__tstate);
44303 if (PyErr_Occurred()) SWIG_fail;
44304 }
44305 {
44306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44307 }
44308 {
44309 if (temp8)
44310 delete arg8;
44311 }
44312 return resultobj;
44313 fail:
44314 {
44315 if (temp8)
44316 delete arg8;
44317 }
44318 return NULL;
44319 }
44320
44321
44322 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44323 PyObject *resultobj = 0;
44324 wxControl *arg1 = (wxControl *) 0 ;
44325 int result;
44326 void *argp1 = 0 ;
44327 int res1 = 0 ;
44328 PyObject *swig_obj[1] ;
44329
44330 if (!args) SWIG_fail;
44331 swig_obj[0] = args;
44332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44333 if (!SWIG_IsOK(res1)) {
44334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44335 }
44336 arg1 = reinterpret_cast< wxControl * >(argp1);
44337 {
44338 PyThreadState* __tstate = wxPyBeginAllowThreads();
44339 result = (int)((wxControl const *)arg1)->GetAlignment();
44340 wxPyEndAllowThreads(__tstate);
44341 if (PyErr_Occurred()) SWIG_fail;
44342 }
44343 resultobj = SWIG_From_int(static_cast< int >(result));
44344 return resultobj;
44345 fail:
44346 return NULL;
44347 }
44348
44349
44350 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44351 PyObject *resultobj = 0;
44352 wxControl *arg1 = (wxControl *) 0 ;
44353 wxString result;
44354 void *argp1 = 0 ;
44355 int res1 = 0 ;
44356 PyObject *swig_obj[1] ;
44357
44358 if (!args) SWIG_fail;
44359 swig_obj[0] = args;
44360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44361 if (!SWIG_IsOK(res1)) {
44362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44363 }
44364 arg1 = reinterpret_cast< wxControl * >(argp1);
44365 {
44366 PyThreadState* __tstate = wxPyBeginAllowThreads();
44367 result = ((wxControl const *)arg1)->GetLabelText();
44368 wxPyEndAllowThreads(__tstate);
44369 if (PyErr_Occurred()) SWIG_fail;
44370 }
44371 {
44372 #if wxUSE_UNICODE
44373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44374 #else
44375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44376 #endif
44377 }
44378 return resultobj;
44379 fail:
44380 return NULL;
44381 }
44382
44383
44384 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44385 PyObject *resultobj = 0;
44386 wxControl *arg1 = (wxControl *) 0 ;
44387 wxCommandEvent *arg2 = 0 ;
44388 void *argp1 = 0 ;
44389 int res1 = 0 ;
44390 void *argp2 = 0 ;
44391 int res2 = 0 ;
44392 PyObject * obj0 = 0 ;
44393 PyObject * obj1 = 0 ;
44394 char * kwnames[] = {
44395 (char *) "self",(char *) "event", NULL
44396 };
44397
44398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44400 if (!SWIG_IsOK(res1)) {
44401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44402 }
44403 arg1 = reinterpret_cast< wxControl * >(argp1);
44404 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44405 if (!SWIG_IsOK(res2)) {
44406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44407 }
44408 if (!argp2) {
44409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44410 }
44411 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44412 {
44413 PyThreadState* __tstate = wxPyBeginAllowThreads();
44414 (arg1)->Command(*arg2);
44415 wxPyEndAllowThreads(__tstate);
44416 if (PyErr_Occurred()) SWIG_fail;
44417 }
44418 resultobj = SWIG_Py_Void();
44419 return resultobj;
44420 fail:
44421 return NULL;
44422 }
44423
44424
44425 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44426 PyObject *resultobj = 0;
44427 wxControl *arg1 = (wxControl *) 0 ;
44428 wxString result;
44429 void *argp1 = 0 ;
44430 int res1 = 0 ;
44431 PyObject *swig_obj[1] ;
44432
44433 if (!args) SWIG_fail;
44434 swig_obj[0] = args;
44435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44436 if (!SWIG_IsOK(res1)) {
44437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44438 }
44439 arg1 = reinterpret_cast< wxControl * >(argp1);
44440 {
44441 PyThreadState* __tstate = wxPyBeginAllowThreads();
44442 result = (arg1)->GetLabel();
44443 wxPyEndAllowThreads(__tstate);
44444 if (PyErr_Occurred()) SWIG_fail;
44445 }
44446 {
44447 #if wxUSE_UNICODE
44448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44449 #else
44450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44451 #endif
44452 }
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44460 PyObject *resultobj = 0;
44461 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44462 SwigValueWrapper<wxVisualAttributes > result;
44463 int val1 ;
44464 int ecode1 = 0 ;
44465 PyObject * obj0 = 0 ;
44466 char * kwnames[] = {
44467 (char *) "variant", NULL
44468 };
44469
44470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44471 if (obj0) {
44472 ecode1 = SWIG_AsVal_int(obj0, &val1);
44473 if (!SWIG_IsOK(ecode1)) {
44474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44475 }
44476 arg1 = static_cast< wxWindowVariant >(val1);
44477 }
44478 {
44479 if (!wxPyCheckForApp()) SWIG_fail;
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 result = wxControl::GetClassDefaultAttributes(arg1);
44482 wxPyEndAllowThreads(__tstate);
44483 if (PyErr_Occurred()) SWIG_fail;
44484 }
44485 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44486 return resultobj;
44487 fail:
44488 return NULL;
44489 }
44490
44491
44492 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44493 PyObject *obj;
44494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44495 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44496 return SWIG_Py_Void();
44497 }
44498
44499 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44500 return SWIG_Python_InitShadowInstance(args);
44501 }
44502
44503 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj = 0;
44505 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44506 wxString *arg2 = 0 ;
44507 PyObject *arg3 = (PyObject *) NULL ;
44508 int result;
44509 void *argp1 = 0 ;
44510 int res1 = 0 ;
44511 bool temp2 = false ;
44512 PyObject * obj0 = 0 ;
44513 PyObject * obj1 = 0 ;
44514 PyObject * obj2 = 0 ;
44515 char * kwnames[] = {
44516 (char *) "self",(char *) "item",(char *) "clientData", NULL
44517 };
44518
44519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44521 if (!SWIG_IsOK(res1)) {
44522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44523 }
44524 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44525 {
44526 arg2 = wxString_in_helper(obj1);
44527 if (arg2 == NULL) SWIG_fail;
44528 temp2 = true;
44529 }
44530 if (obj2) {
44531 arg3 = obj2;
44532 }
44533 {
44534 PyThreadState* __tstate = wxPyBeginAllowThreads();
44535 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44536 wxPyEndAllowThreads(__tstate);
44537 if (PyErr_Occurred()) SWIG_fail;
44538 }
44539 resultobj = SWIG_From_int(static_cast< int >(result));
44540 {
44541 if (temp2)
44542 delete arg2;
44543 }
44544 return resultobj;
44545 fail:
44546 {
44547 if (temp2)
44548 delete arg2;
44549 }
44550 return NULL;
44551 }
44552
44553
44554 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44555 PyObject *resultobj = 0;
44556 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44557 wxArrayString *arg2 = 0 ;
44558 void *argp1 = 0 ;
44559 int res1 = 0 ;
44560 bool temp2 = false ;
44561 PyObject * obj0 = 0 ;
44562 PyObject * obj1 = 0 ;
44563 char * kwnames[] = {
44564 (char *) "self",(char *) "strings", NULL
44565 };
44566
44567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44569 if (!SWIG_IsOK(res1)) {
44570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44571 }
44572 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44573 {
44574 if (! PySequence_Check(obj1)) {
44575 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44576 SWIG_fail;
44577 }
44578 arg2 = new wxArrayString;
44579 temp2 = true;
44580 int i, len=PySequence_Length(obj1);
44581 for (i=0; i<len; i++) {
44582 PyObject* item = PySequence_GetItem(obj1, i);
44583 wxString* s = wxString_in_helper(item);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 arg2->Add(*s);
44586 delete s;
44587 Py_DECREF(item);
44588 }
44589 }
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 (arg1)->Append((wxArrayString const &)*arg2);
44593 wxPyEndAllowThreads(__tstate);
44594 if (PyErr_Occurred()) SWIG_fail;
44595 }
44596 resultobj = SWIG_Py_Void();
44597 {
44598 if (temp2) delete arg2;
44599 }
44600 return resultobj;
44601 fail:
44602 {
44603 if (temp2) delete arg2;
44604 }
44605 return NULL;
44606 }
44607
44608
44609 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44610 PyObject *resultobj = 0;
44611 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44612 wxString *arg2 = 0 ;
44613 unsigned int arg3 ;
44614 PyObject *arg4 = (PyObject *) NULL ;
44615 int result;
44616 void *argp1 = 0 ;
44617 int res1 = 0 ;
44618 bool temp2 = false ;
44619 unsigned int val3 ;
44620 int ecode3 = 0 ;
44621 PyObject * obj0 = 0 ;
44622 PyObject * obj1 = 0 ;
44623 PyObject * obj2 = 0 ;
44624 PyObject * obj3 = 0 ;
44625 char * kwnames[] = {
44626 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44627 };
44628
44629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44633 }
44634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44635 {
44636 arg2 = wxString_in_helper(obj1);
44637 if (arg2 == NULL) SWIG_fail;
44638 temp2 = true;
44639 }
44640 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44641 if (!SWIG_IsOK(ecode3)) {
44642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44643 }
44644 arg3 = static_cast< unsigned int >(val3);
44645 if (obj3) {
44646 arg4 = obj3;
44647 }
44648 {
44649 PyThreadState* __tstate = wxPyBeginAllowThreads();
44650 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44651 wxPyEndAllowThreads(__tstate);
44652 if (PyErr_Occurred()) SWIG_fail;
44653 }
44654 resultobj = SWIG_From_int(static_cast< int >(result));
44655 {
44656 if (temp2)
44657 delete arg2;
44658 }
44659 return resultobj;
44660 fail:
44661 {
44662 if (temp2)
44663 delete arg2;
44664 }
44665 return NULL;
44666 }
44667
44668
44669 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44670 PyObject *resultobj = 0;
44671 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44672 void *argp1 = 0 ;
44673 int res1 = 0 ;
44674 PyObject *swig_obj[1] ;
44675
44676 if (!args) SWIG_fail;
44677 swig_obj[0] = args;
44678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44679 if (!SWIG_IsOK(res1)) {
44680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44681 }
44682 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 (arg1)->Clear();
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 resultobj = SWIG_Py_Void();
44690 return resultobj;
44691 fail:
44692 return NULL;
44693 }
44694
44695
44696 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44697 PyObject *resultobj = 0;
44698 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44699 unsigned int arg2 ;
44700 void *argp1 = 0 ;
44701 int res1 = 0 ;
44702 unsigned int val2 ;
44703 int ecode2 = 0 ;
44704 PyObject * obj0 = 0 ;
44705 PyObject * obj1 = 0 ;
44706 char * kwnames[] = {
44707 (char *) "self",(char *) "n", NULL
44708 };
44709
44710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44712 if (!SWIG_IsOK(res1)) {
44713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44714 }
44715 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44716 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44717 if (!SWIG_IsOK(ecode2)) {
44718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44719 }
44720 arg2 = static_cast< unsigned int >(val2);
44721 {
44722 PyThreadState* __tstate = wxPyBeginAllowThreads();
44723 (arg1)->Delete(arg2);
44724 wxPyEndAllowThreads(__tstate);
44725 if (PyErr_Occurred()) SWIG_fail;
44726 }
44727 resultobj = SWIG_Py_Void();
44728 return resultobj;
44729 fail:
44730 return NULL;
44731 }
44732
44733
44734 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44735 PyObject *resultobj = 0;
44736 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44737 unsigned int arg2 ;
44738 PyObject *result = 0 ;
44739 void *argp1 = 0 ;
44740 int res1 = 0 ;
44741 unsigned int val2 ;
44742 int ecode2 = 0 ;
44743 PyObject * obj0 = 0 ;
44744 PyObject * obj1 = 0 ;
44745 char * kwnames[] = {
44746 (char *) "self",(char *) "n", NULL
44747 };
44748
44749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44751 if (!SWIG_IsOK(res1)) {
44752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44753 }
44754 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44755 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44756 if (!SWIG_IsOK(ecode2)) {
44757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44758 }
44759 arg2 = static_cast< unsigned int >(val2);
44760 {
44761 PyThreadState* __tstate = wxPyBeginAllowThreads();
44762 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44763 wxPyEndAllowThreads(__tstate);
44764 if (PyErr_Occurred()) SWIG_fail;
44765 }
44766 resultobj = result;
44767 return resultobj;
44768 fail:
44769 return NULL;
44770 }
44771
44772
44773 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44774 PyObject *resultobj = 0;
44775 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44776 unsigned int arg2 ;
44777 PyObject *arg3 = (PyObject *) 0 ;
44778 void *argp1 = 0 ;
44779 int res1 = 0 ;
44780 unsigned int val2 ;
44781 int ecode2 = 0 ;
44782 PyObject * obj0 = 0 ;
44783 PyObject * obj1 = 0 ;
44784 PyObject * obj2 = 0 ;
44785 char * kwnames[] = {
44786 (char *) "self",(char *) "n",(char *) "clientData", NULL
44787 };
44788
44789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44791 if (!SWIG_IsOK(res1)) {
44792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44793 }
44794 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44795 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44796 if (!SWIG_IsOK(ecode2)) {
44797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44798 }
44799 arg2 = static_cast< unsigned int >(val2);
44800 arg3 = obj2;
44801 {
44802 PyThreadState* __tstate = wxPyBeginAllowThreads();
44803 wxItemContainer_SetClientData(arg1,arg2,arg3);
44804 wxPyEndAllowThreads(__tstate);
44805 if (PyErr_Occurred()) SWIG_fail;
44806 }
44807 resultobj = SWIG_Py_Void();
44808 return resultobj;
44809 fail:
44810 return NULL;
44811 }
44812
44813
44814 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44815 PyObject *resultobj = 0;
44816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44817 unsigned int result;
44818 void *argp1 = 0 ;
44819 int res1 = 0 ;
44820 PyObject *swig_obj[1] ;
44821
44822 if (!args) SWIG_fail;
44823 swig_obj[0] = args;
44824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44825 if (!SWIG_IsOK(res1)) {
44826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44827 }
44828 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44829 {
44830 PyThreadState* __tstate = wxPyBeginAllowThreads();
44831 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44832 wxPyEndAllowThreads(__tstate);
44833 if (PyErr_Occurred()) SWIG_fail;
44834 }
44835 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44843 PyObject *resultobj = 0;
44844 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44845 bool result;
44846 void *argp1 = 0 ;
44847 int res1 = 0 ;
44848 PyObject *swig_obj[1] ;
44849
44850 if (!args) SWIG_fail;
44851 swig_obj[0] = args;
44852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44853 if (!SWIG_IsOK(res1)) {
44854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44855 }
44856 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44857 {
44858 PyThreadState* __tstate = wxPyBeginAllowThreads();
44859 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44860 wxPyEndAllowThreads(__tstate);
44861 if (PyErr_Occurred()) SWIG_fail;
44862 }
44863 {
44864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44865 }
44866 return resultobj;
44867 fail:
44868 return NULL;
44869 }
44870
44871
44872 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44873 PyObject *resultobj = 0;
44874 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44875 unsigned int arg2 ;
44876 wxString result;
44877 void *argp1 = 0 ;
44878 int res1 = 0 ;
44879 unsigned int val2 ;
44880 int ecode2 = 0 ;
44881 PyObject * obj0 = 0 ;
44882 PyObject * obj1 = 0 ;
44883 char * kwnames[] = {
44884 (char *) "self",(char *) "n", NULL
44885 };
44886
44887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44889 if (!SWIG_IsOK(res1)) {
44890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44891 }
44892 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44893 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44894 if (!SWIG_IsOK(ecode2)) {
44895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44896 }
44897 arg2 = static_cast< unsigned int >(val2);
44898 {
44899 PyThreadState* __tstate = wxPyBeginAllowThreads();
44900 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44901 wxPyEndAllowThreads(__tstate);
44902 if (PyErr_Occurred()) SWIG_fail;
44903 }
44904 {
44905 #if wxUSE_UNICODE
44906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44907 #else
44908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44909 #endif
44910 }
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *resultobj = 0;
44919 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44920 wxArrayString result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 PyObject *swig_obj[1] ;
44924
44925 if (!args) SWIG_fail;
44926 swig_obj[0] = args;
44927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44930 }
44931 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = ((wxItemContainer const *)arg1)->GetStrings();
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 {
44939 resultobj = wxArrayString2PyList_helper(result);
44940 }
44941 return resultobj;
44942 fail:
44943 return NULL;
44944 }
44945
44946
44947 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj = 0;
44949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44950 unsigned int arg2 ;
44951 wxString *arg3 = 0 ;
44952 void *argp1 = 0 ;
44953 int res1 = 0 ;
44954 unsigned int val2 ;
44955 int ecode2 = 0 ;
44956 bool temp3 = false ;
44957 PyObject * obj0 = 0 ;
44958 PyObject * obj1 = 0 ;
44959 PyObject * obj2 = 0 ;
44960 char * kwnames[] = {
44961 (char *) "self",(char *) "n",(char *) "s", NULL
44962 };
44963
44964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44966 if (!SWIG_IsOK(res1)) {
44967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44968 }
44969 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44970 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44971 if (!SWIG_IsOK(ecode2)) {
44972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44973 }
44974 arg2 = static_cast< unsigned int >(val2);
44975 {
44976 arg3 = wxString_in_helper(obj2);
44977 if (arg3 == NULL) SWIG_fail;
44978 temp3 = true;
44979 }
44980 {
44981 PyThreadState* __tstate = wxPyBeginAllowThreads();
44982 (arg1)->SetString(arg2,(wxString const &)*arg3);
44983 wxPyEndAllowThreads(__tstate);
44984 if (PyErr_Occurred()) SWIG_fail;
44985 }
44986 resultobj = SWIG_Py_Void();
44987 {
44988 if (temp3)
44989 delete arg3;
44990 }
44991 return resultobj;
44992 fail:
44993 {
44994 if (temp3)
44995 delete arg3;
44996 }
44997 return NULL;
44998 }
44999
45000
45001 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45002 PyObject *resultobj = 0;
45003 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45004 wxString *arg2 = 0 ;
45005 int result;
45006 void *argp1 = 0 ;
45007 int res1 = 0 ;
45008 bool temp2 = false ;
45009 PyObject * obj0 = 0 ;
45010 PyObject * obj1 = 0 ;
45011 char * kwnames[] = {
45012 (char *) "self",(char *) "s", NULL
45013 };
45014
45015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45017 if (!SWIG_IsOK(res1)) {
45018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45019 }
45020 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45021 {
45022 arg2 = wxString_in_helper(obj1);
45023 if (arg2 == NULL) SWIG_fail;
45024 temp2 = true;
45025 }
45026 {
45027 PyThreadState* __tstate = wxPyBeginAllowThreads();
45028 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45029 wxPyEndAllowThreads(__tstate);
45030 if (PyErr_Occurred()) SWIG_fail;
45031 }
45032 resultobj = SWIG_From_int(static_cast< int >(result));
45033 {
45034 if (temp2)
45035 delete arg2;
45036 }
45037 return resultobj;
45038 fail:
45039 {
45040 if (temp2)
45041 delete arg2;
45042 }
45043 return NULL;
45044 }
45045
45046
45047 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45048 PyObject *resultobj = 0;
45049 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45050 int arg2 ;
45051 void *argp1 = 0 ;
45052 int res1 = 0 ;
45053 int val2 ;
45054 int ecode2 = 0 ;
45055 PyObject * obj0 = 0 ;
45056 PyObject * obj1 = 0 ;
45057 char * kwnames[] = {
45058 (char *) "self",(char *) "n", NULL
45059 };
45060
45061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45063 if (!SWIG_IsOK(res1)) {
45064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45065 }
45066 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45067 ecode2 = SWIG_AsVal_int(obj1, &val2);
45068 if (!SWIG_IsOK(ecode2)) {
45069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45070 }
45071 arg2 = static_cast< int >(val2);
45072 {
45073 PyThreadState* __tstate = wxPyBeginAllowThreads();
45074 (arg1)->SetSelection(arg2);
45075 wxPyEndAllowThreads(__tstate);
45076 if (PyErr_Occurred()) SWIG_fail;
45077 }
45078 resultobj = SWIG_Py_Void();
45079 return resultobj;
45080 fail:
45081 return NULL;
45082 }
45083
45084
45085 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45086 PyObject *resultobj = 0;
45087 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45088 int result;
45089 void *argp1 = 0 ;
45090 int res1 = 0 ;
45091 PyObject *swig_obj[1] ;
45092
45093 if (!args) SWIG_fail;
45094 swig_obj[0] = args;
45095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45096 if (!SWIG_IsOK(res1)) {
45097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45098 }
45099 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45100 {
45101 PyThreadState* __tstate = wxPyBeginAllowThreads();
45102 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45103 wxPyEndAllowThreads(__tstate);
45104 if (PyErr_Occurred()) SWIG_fail;
45105 }
45106 resultobj = SWIG_From_int(static_cast< int >(result));
45107 return resultobj;
45108 fail:
45109 return NULL;
45110 }
45111
45112
45113 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45114 PyObject *resultobj = 0;
45115 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45116 wxString *arg2 = 0 ;
45117 bool result;
45118 void *argp1 = 0 ;
45119 int res1 = 0 ;
45120 bool temp2 = false ;
45121 PyObject * obj0 = 0 ;
45122 PyObject * obj1 = 0 ;
45123 char * kwnames[] = {
45124 (char *) "self",(char *) "s", NULL
45125 };
45126
45127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45129 if (!SWIG_IsOK(res1)) {
45130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45131 }
45132 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45133 {
45134 arg2 = wxString_in_helper(obj1);
45135 if (arg2 == NULL) SWIG_fail;
45136 temp2 = true;
45137 }
45138 {
45139 PyThreadState* __tstate = wxPyBeginAllowThreads();
45140 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45141 wxPyEndAllowThreads(__tstate);
45142 if (PyErr_Occurred()) SWIG_fail;
45143 }
45144 {
45145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45146 }
45147 {
45148 if (temp2)
45149 delete arg2;
45150 }
45151 return resultobj;
45152 fail:
45153 {
45154 if (temp2)
45155 delete arg2;
45156 }
45157 return NULL;
45158 }
45159
45160
45161 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45162 PyObject *resultobj = 0;
45163 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45164 wxString result;
45165 void *argp1 = 0 ;
45166 int res1 = 0 ;
45167 PyObject *swig_obj[1] ;
45168
45169 if (!args) SWIG_fail;
45170 swig_obj[0] = args;
45171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45172 if (!SWIG_IsOK(res1)) {
45173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45174 }
45175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45176 {
45177 PyThreadState* __tstate = wxPyBeginAllowThreads();
45178 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45179 wxPyEndAllowThreads(__tstate);
45180 if (PyErr_Occurred()) SWIG_fail;
45181 }
45182 {
45183 #if wxUSE_UNICODE
45184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45185 #else
45186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45187 #endif
45188 }
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45196 PyObject *resultobj = 0;
45197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45198 int arg2 ;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 int val2 ;
45202 int ecode2 = 0 ;
45203 PyObject * obj0 = 0 ;
45204 PyObject * obj1 = 0 ;
45205 char * kwnames[] = {
45206 (char *) "self",(char *) "n", NULL
45207 };
45208
45209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45211 if (!SWIG_IsOK(res1)) {
45212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45213 }
45214 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45215 ecode2 = SWIG_AsVal_int(obj1, &val2);
45216 if (!SWIG_IsOK(ecode2)) {
45217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45218 }
45219 arg2 = static_cast< int >(val2);
45220 {
45221 PyThreadState* __tstate = wxPyBeginAllowThreads();
45222 (arg1)->Select(arg2);
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 resultobj = SWIG_Py_Void();
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45234 PyObject *obj;
45235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45236 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45237 return SWIG_Py_Void();
45238 }
45239
45240 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45241 PyObject *obj;
45242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45243 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45244 return SWIG_Py_Void();
45245 }
45246
45247 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45248 PyObject *resultobj = 0;
45249 wxSizerItem *result = 0 ;
45250
45251 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 result = (wxSizerItem *)new wxSizerItem();
45255 wxPyEndAllowThreads(__tstate);
45256 if (PyErr_Occurred()) SWIG_fail;
45257 }
45258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45266 PyObject *resultobj = 0;
45267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45268 void *argp1 = 0 ;
45269 int res1 = 0 ;
45270 PyObject *swig_obj[1] ;
45271
45272 if (!args) SWIG_fail;
45273 swig_obj[0] = args;
45274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45275 if (!SWIG_IsOK(res1)) {
45276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45277 }
45278 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45279 {
45280 PyThreadState* __tstate = wxPyBeginAllowThreads();
45281 delete arg1;
45282
45283 wxPyEndAllowThreads(__tstate);
45284 if (PyErr_Occurred()) SWIG_fail;
45285 }
45286 resultobj = SWIG_Py_Void();
45287 return resultobj;
45288 fail:
45289 return NULL;
45290 }
45291
45292
45293 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45294 PyObject *resultobj = 0;
45295 wxWindow *arg1 = (wxWindow *) 0 ;
45296 int arg2 ;
45297 int arg3 ;
45298 int arg4 ;
45299 PyObject *arg5 = (PyObject *) NULL ;
45300 wxSizerItem *result = 0 ;
45301 void *argp1 = 0 ;
45302 int res1 = 0 ;
45303 int val2 ;
45304 int ecode2 = 0 ;
45305 int val3 ;
45306 int ecode3 = 0 ;
45307 int val4 ;
45308 int ecode4 = 0 ;
45309 PyObject * obj0 = 0 ;
45310 PyObject * obj1 = 0 ;
45311 PyObject * obj2 = 0 ;
45312 PyObject * obj3 = 0 ;
45313 PyObject * obj4 = 0 ;
45314 char * kwnames[] = {
45315 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45316 };
45317
45318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45320 if (!SWIG_IsOK(res1)) {
45321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45322 }
45323 arg1 = reinterpret_cast< wxWindow * >(argp1);
45324 ecode2 = SWIG_AsVal_int(obj1, &val2);
45325 if (!SWIG_IsOK(ecode2)) {
45326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45327 }
45328 arg2 = static_cast< int >(val2);
45329 ecode3 = SWIG_AsVal_int(obj2, &val3);
45330 if (!SWIG_IsOK(ecode3)) {
45331 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45332 }
45333 arg3 = static_cast< int >(val3);
45334 ecode4 = SWIG_AsVal_int(obj3, &val4);
45335 if (!SWIG_IsOK(ecode4)) {
45336 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45337 }
45338 arg4 = static_cast< int >(val4);
45339 if (obj4) {
45340 arg5 = obj4;
45341 }
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45349 return resultobj;
45350 fail:
45351 return NULL;
45352 }
45353
45354
45355 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45356 PyObject *resultobj = 0;
45357 int arg1 ;
45358 int arg2 ;
45359 int arg3 ;
45360 int arg4 ;
45361 int arg5 ;
45362 PyObject *arg6 = (PyObject *) NULL ;
45363 wxSizerItem *result = 0 ;
45364 int val1 ;
45365 int ecode1 = 0 ;
45366 int val2 ;
45367 int ecode2 = 0 ;
45368 int val3 ;
45369 int ecode3 = 0 ;
45370 int val4 ;
45371 int ecode4 = 0 ;
45372 int val5 ;
45373 int ecode5 = 0 ;
45374 PyObject * obj0 = 0 ;
45375 PyObject * obj1 = 0 ;
45376 PyObject * obj2 = 0 ;
45377 PyObject * obj3 = 0 ;
45378 PyObject * obj4 = 0 ;
45379 PyObject * obj5 = 0 ;
45380 char * kwnames[] = {
45381 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45382 };
45383
45384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45385 ecode1 = SWIG_AsVal_int(obj0, &val1);
45386 if (!SWIG_IsOK(ecode1)) {
45387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45388 }
45389 arg1 = static_cast< int >(val1);
45390 ecode2 = SWIG_AsVal_int(obj1, &val2);
45391 if (!SWIG_IsOK(ecode2)) {
45392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45393 }
45394 arg2 = static_cast< int >(val2);
45395 ecode3 = SWIG_AsVal_int(obj2, &val3);
45396 if (!SWIG_IsOK(ecode3)) {
45397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45398 }
45399 arg3 = static_cast< int >(val3);
45400 ecode4 = SWIG_AsVal_int(obj3, &val4);
45401 if (!SWIG_IsOK(ecode4)) {
45402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45403 }
45404 arg4 = static_cast< int >(val4);
45405 ecode5 = SWIG_AsVal_int(obj4, &val5);
45406 if (!SWIG_IsOK(ecode5)) {
45407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45408 }
45409 arg5 = static_cast< int >(val5);
45410 if (obj5) {
45411 arg6 = obj5;
45412 }
45413 {
45414 PyThreadState* __tstate = wxPyBeginAllowThreads();
45415 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45416 wxPyEndAllowThreads(__tstate);
45417 if (PyErr_Occurred()) SWIG_fail;
45418 }
45419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45420 return resultobj;
45421 fail:
45422 return NULL;
45423 }
45424
45425
45426 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45427 PyObject *resultobj = 0;
45428 wxSizer *arg1 = (wxSizer *) 0 ;
45429 int arg2 ;
45430 int arg3 ;
45431 int arg4 ;
45432 PyObject *arg5 = (PyObject *) NULL ;
45433 wxSizerItem *result = 0 ;
45434 int res1 = 0 ;
45435 int val2 ;
45436 int ecode2 = 0 ;
45437 int val3 ;
45438 int ecode3 = 0 ;
45439 int val4 ;
45440 int ecode4 = 0 ;
45441 PyObject * obj0 = 0 ;
45442 PyObject * obj1 = 0 ;
45443 PyObject * obj2 = 0 ;
45444 PyObject * obj3 = 0 ;
45445 PyObject * obj4 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45454 }
45455 ecode2 = SWIG_AsVal_int(obj1, &val2);
45456 if (!SWIG_IsOK(ecode2)) {
45457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45458 }
45459 arg2 = static_cast< int >(val2);
45460 ecode3 = SWIG_AsVal_int(obj2, &val3);
45461 if (!SWIG_IsOK(ecode3)) {
45462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45463 }
45464 arg3 = static_cast< int >(val3);
45465 ecode4 = SWIG_AsVal_int(obj3, &val4);
45466 if (!SWIG_IsOK(ecode4)) {
45467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45468 }
45469 arg4 = static_cast< int >(val4);
45470 if (obj4) {
45471 arg5 = obj4;
45472 }
45473 {
45474 PyThreadState* __tstate = wxPyBeginAllowThreads();
45475 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45476 wxPyEndAllowThreads(__tstate);
45477 if (PyErr_Occurred()) SWIG_fail;
45478 }
45479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45480 return resultobj;
45481 fail:
45482 return NULL;
45483 }
45484
45485
45486 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45487 PyObject *resultobj = 0;
45488 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45489 void *argp1 = 0 ;
45490 int res1 = 0 ;
45491 PyObject *swig_obj[1] ;
45492
45493 if (!args) SWIG_fail;
45494 swig_obj[0] = args;
45495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45496 if (!SWIG_IsOK(res1)) {
45497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45498 }
45499 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45500 {
45501 PyThreadState* __tstate = wxPyBeginAllowThreads();
45502 (arg1)->DeleteWindows();
45503 wxPyEndAllowThreads(__tstate);
45504 if (PyErr_Occurred()) SWIG_fail;
45505 }
45506 resultobj = SWIG_Py_Void();
45507 return resultobj;
45508 fail:
45509 return NULL;
45510 }
45511
45512
45513 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45514 PyObject *resultobj = 0;
45515 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45516 void *argp1 = 0 ;
45517 int res1 = 0 ;
45518 PyObject *swig_obj[1] ;
45519
45520 if (!args) SWIG_fail;
45521 swig_obj[0] = args;
45522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45523 if (!SWIG_IsOK(res1)) {
45524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45525 }
45526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45527 {
45528 PyThreadState* __tstate = wxPyBeginAllowThreads();
45529 (arg1)->DetachSizer();
45530 wxPyEndAllowThreads(__tstate);
45531 if (PyErr_Occurred()) SWIG_fail;
45532 }
45533 resultobj = SWIG_Py_Void();
45534 return resultobj;
45535 fail:
45536 return NULL;
45537 }
45538
45539
45540 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45541 PyObject *resultobj = 0;
45542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45543 wxSize result;
45544 void *argp1 = 0 ;
45545 int res1 = 0 ;
45546 PyObject *swig_obj[1] ;
45547
45548 if (!args) SWIG_fail;
45549 swig_obj[0] = args;
45550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45551 if (!SWIG_IsOK(res1)) {
45552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45553 }
45554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45555 {
45556 PyThreadState* __tstate = wxPyBeginAllowThreads();
45557 result = (arg1)->GetSize();
45558 wxPyEndAllowThreads(__tstate);
45559 if (PyErr_Occurred()) SWIG_fail;
45560 }
45561 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45562 return resultobj;
45563 fail:
45564 return NULL;
45565 }
45566
45567
45568 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45569 PyObject *resultobj = 0;
45570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45571 wxSize result;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 PyObject *swig_obj[1] ;
45575
45576 if (!args) SWIG_fail;
45577 swig_obj[0] = args;
45578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45579 if (!SWIG_IsOK(res1)) {
45580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45581 }
45582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45583 {
45584 PyThreadState* __tstate = wxPyBeginAllowThreads();
45585 result = (arg1)->CalcMin();
45586 wxPyEndAllowThreads(__tstate);
45587 if (PyErr_Occurred()) SWIG_fail;
45588 }
45589 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45590 return resultobj;
45591 fail:
45592 return NULL;
45593 }
45594
45595
45596 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45597 PyObject *resultobj = 0;
45598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45599 wxPoint *arg2 = 0 ;
45600 wxSize *arg3 = 0 ;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 wxPoint temp2 ;
45604 wxSize temp3 ;
45605 PyObject * obj0 = 0 ;
45606 PyObject * obj1 = 0 ;
45607 PyObject * obj2 = 0 ;
45608 char * kwnames[] = {
45609 (char *) "self",(char *) "pos",(char *) "size", NULL
45610 };
45611
45612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45614 if (!SWIG_IsOK(res1)) {
45615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45616 }
45617 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45618 {
45619 arg2 = &temp2;
45620 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45621 }
45622 {
45623 arg3 = &temp3;
45624 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45625 }
45626 {
45627 PyThreadState* __tstate = wxPyBeginAllowThreads();
45628 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45629 wxPyEndAllowThreads(__tstate);
45630 if (PyErr_Occurred()) SWIG_fail;
45631 }
45632 resultobj = SWIG_Py_Void();
45633 return resultobj;
45634 fail:
45635 return NULL;
45636 }
45637
45638
45639 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45640 PyObject *resultobj = 0;
45641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45642 wxSize result;
45643 void *argp1 = 0 ;
45644 int res1 = 0 ;
45645 PyObject *swig_obj[1] ;
45646
45647 if (!args) SWIG_fail;
45648 swig_obj[0] = args;
45649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45650 if (!SWIG_IsOK(res1)) {
45651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45652 }
45653 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45654 {
45655 PyThreadState* __tstate = wxPyBeginAllowThreads();
45656 result = (arg1)->GetMinSize();
45657 wxPyEndAllowThreads(__tstate);
45658 if (PyErr_Occurred()) SWIG_fail;
45659 }
45660 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45661 return resultobj;
45662 fail:
45663 return NULL;
45664 }
45665
45666
45667 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45668 PyObject *resultobj = 0;
45669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45670 wxSize result;
45671 void *argp1 = 0 ;
45672 int res1 = 0 ;
45673 PyObject *swig_obj[1] ;
45674
45675 if (!args) SWIG_fail;
45676 swig_obj[0] = args;
45677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45678 if (!SWIG_IsOK(res1)) {
45679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45680 }
45681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45682 {
45683 PyThreadState* __tstate = wxPyBeginAllowThreads();
45684 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45685 wxPyEndAllowThreads(__tstate);
45686 if (PyErr_Occurred()) SWIG_fail;
45687 }
45688 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45689 return resultobj;
45690 fail:
45691 return NULL;
45692 }
45693
45694
45695 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45696 PyObject *resultobj = 0;
45697 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45698 int arg2 ;
45699 int arg3 ;
45700 void *argp1 = 0 ;
45701 int res1 = 0 ;
45702 int val2 ;
45703 int ecode2 = 0 ;
45704 int val3 ;
45705 int ecode3 = 0 ;
45706 PyObject * obj0 = 0 ;
45707 PyObject * obj1 = 0 ;
45708 PyObject * obj2 = 0 ;
45709 char * kwnames[] = {
45710 (char *) "self",(char *) "x",(char *) "y", NULL
45711 };
45712
45713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45715 if (!SWIG_IsOK(res1)) {
45716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45717 }
45718 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45719 ecode2 = SWIG_AsVal_int(obj1, &val2);
45720 if (!SWIG_IsOK(ecode2)) {
45721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45722 }
45723 arg2 = static_cast< int >(val2);
45724 ecode3 = SWIG_AsVal_int(obj2, &val3);
45725 if (!SWIG_IsOK(ecode3)) {
45726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45727 }
45728 arg3 = static_cast< int >(val3);
45729 {
45730 PyThreadState* __tstate = wxPyBeginAllowThreads();
45731 (arg1)->SetInitSize(arg2,arg3);
45732 wxPyEndAllowThreads(__tstate);
45733 if (PyErr_Occurred()) SWIG_fail;
45734 }
45735 resultobj = SWIG_Py_Void();
45736 return resultobj;
45737 fail:
45738 return NULL;
45739 }
45740
45741
45742 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45743 PyObject *resultobj = 0;
45744 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45745 int arg2 ;
45746 int arg3 ;
45747 void *argp1 = 0 ;
45748 int res1 = 0 ;
45749 int val2 ;
45750 int ecode2 = 0 ;
45751 int val3 ;
45752 int ecode3 = 0 ;
45753 PyObject * obj0 = 0 ;
45754 PyObject * obj1 = 0 ;
45755 PyObject * obj2 = 0 ;
45756 char * kwnames[] = {
45757 (char *) "self",(char *) "width",(char *) "height", NULL
45758 };
45759
45760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45762 if (!SWIG_IsOK(res1)) {
45763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45764 }
45765 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45766 ecode2 = SWIG_AsVal_int(obj1, &val2);
45767 if (!SWIG_IsOK(ecode2)) {
45768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45769 }
45770 arg2 = static_cast< int >(val2);
45771 ecode3 = SWIG_AsVal_int(obj2, &val3);
45772 if (!SWIG_IsOK(ecode3)) {
45773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45774 }
45775 arg3 = static_cast< int >(val3);
45776 {
45777 PyThreadState* __tstate = wxPyBeginAllowThreads();
45778 (arg1)->SetRatio(arg2,arg3);
45779 wxPyEndAllowThreads(__tstate);
45780 if (PyErr_Occurred()) SWIG_fail;
45781 }
45782 resultobj = SWIG_Py_Void();
45783 return resultobj;
45784 fail:
45785 return NULL;
45786 }
45787
45788
45789 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45790 PyObject *resultobj = 0;
45791 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45792 wxSize *arg2 = 0 ;
45793 void *argp1 = 0 ;
45794 int res1 = 0 ;
45795 wxSize temp2 ;
45796 PyObject * obj0 = 0 ;
45797 PyObject * obj1 = 0 ;
45798 char * kwnames[] = {
45799 (char *) "self",(char *) "size", NULL
45800 };
45801
45802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45804 if (!SWIG_IsOK(res1)) {
45805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45806 }
45807 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45808 {
45809 arg2 = &temp2;
45810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45811 }
45812 {
45813 PyThreadState* __tstate = wxPyBeginAllowThreads();
45814 (arg1)->SetRatio((wxSize const &)*arg2);
45815 wxPyEndAllowThreads(__tstate);
45816 if (PyErr_Occurred()) SWIG_fail;
45817 }
45818 resultobj = SWIG_Py_Void();
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45826 PyObject *resultobj = 0;
45827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45828 float arg2 ;
45829 void *argp1 = 0 ;
45830 int res1 = 0 ;
45831 float val2 ;
45832 int ecode2 = 0 ;
45833 PyObject * obj0 = 0 ;
45834 PyObject * obj1 = 0 ;
45835 char * kwnames[] = {
45836 (char *) "self",(char *) "ratio", NULL
45837 };
45838
45839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45841 if (!SWIG_IsOK(res1)) {
45842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45843 }
45844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45845 ecode2 = SWIG_AsVal_float(obj1, &val2);
45846 if (!SWIG_IsOK(ecode2)) {
45847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45848 }
45849 arg2 = static_cast< float >(val2);
45850 {
45851 PyThreadState* __tstate = wxPyBeginAllowThreads();
45852 (arg1)->SetRatio(arg2);
45853 wxPyEndAllowThreads(__tstate);
45854 if (PyErr_Occurred()) SWIG_fail;
45855 }
45856 resultobj = SWIG_Py_Void();
45857 return resultobj;
45858 fail:
45859 return NULL;
45860 }
45861
45862
45863 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45864 PyObject *resultobj = 0;
45865 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45866 float result;
45867 void *argp1 = 0 ;
45868 int res1 = 0 ;
45869 PyObject *swig_obj[1] ;
45870
45871 if (!args) SWIG_fail;
45872 swig_obj[0] = args;
45873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45874 if (!SWIG_IsOK(res1)) {
45875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45876 }
45877 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45878 {
45879 PyThreadState* __tstate = wxPyBeginAllowThreads();
45880 result = (float)(arg1)->GetRatio();
45881 wxPyEndAllowThreads(__tstate);
45882 if (PyErr_Occurred()) SWIG_fail;
45883 }
45884 resultobj = SWIG_From_float(static_cast< float >(result));
45885 return resultobj;
45886 fail:
45887 return NULL;
45888 }
45889
45890
45891 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45892 PyObject *resultobj = 0;
45893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45894 wxRect result;
45895 void *argp1 = 0 ;
45896 int res1 = 0 ;
45897 PyObject *swig_obj[1] ;
45898
45899 if (!args) SWIG_fail;
45900 swig_obj[0] = args;
45901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45902 if (!SWIG_IsOK(res1)) {
45903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45904 }
45905 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45906 {
45907 PyThreadState* __tstate = wxPyBeginAllowThreads();
45908 result = (arg1)->GetRect();
45909 wxPyEndAllowThreads(__tstate);
45910 if (PyErr_Occurred()) SWIG_fail;
45911 }
45912 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45913 return resultobj;
45914 fail:
45915 return NULL;
45916 }
45917
45918
45919 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45920 PyObject *resultobj = 0;
45921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45922 bool result;
45923 void *argp1 = 0 ;
45924 int res1 = 0 ;
45925 PyObject *swig_obj[1] ;
45926
45927 if (!args) SWIG_fail;
45928 swig_obj[0] = args;
45929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45930 if (!SWIG_IsOK(res1)) {
45931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45932 }
45933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45934 {
45935 PyThreadState* __tstate = wxPyBeginAllowThreads();
45936 result = (bool)(arg1)->IsWindow();
45937 wxPyEndAllowThreads(__tstate);
45938 if (PyErr_Occurred()) SWIG_fail;
45939 }
45940 {
45941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45942 }
45943 return resultobj;
45944 fail:
45945 return NULL;
45946 }
45947
45948
45949 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45950 PyObject *resultobj = 0;
45951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45952 bool result;
45953 void *argp1 = 0 ;
45954 int res1 = 0 ;
45955 PyObject *swig_obj[1] ;
45956
45957 if (!args) SWIG_fail;
45958 swig_obj[0] = args;
45959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45960 if (!SWIG_IsOK(res1)) {
45961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45962 }
45963 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45964 {
45965 PyThreadState* __tstate = wxPyBeginAllowThreads();
45966 result = (bool)(arg1)->IsSizer();
45967 wxPyEndAllowThreads(__tstate);
45968 if (PyErr_Occurred()) SWIG_fail;
45969 }
45970 {
45971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45972 }
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45980 PyObject *resultobj = 0;
45981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45982 bool result;
45983 void *argp1 = 0 ;
45984 int res1 = 0 ;
45985 PyObject *swig_obj[1] ;
45986
45987 if (!args) SWIG_fail;
45988 swig_obj[0] = args;
45989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45990 if (!SWIG_IsOK(res1)) {
45991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45992 }
45993 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45994 {
45995 PyThreadState* __tstate = wxPyBeginAllowThreads();
45996 result = (bool)(arg1)->IsSpacer();
45997 wxPyEndAllowThreads(__tstate);
45998 if (PyErr_Occurred()) SWIG_fail;
45999 }
46000 {
46001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46002 }
46003 return resultobj;
46004 fail:
46005 return NULL;
46006 }
46007
46008
46009 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46010 PyObject *resultobj = 0;
46011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46012 int arg2 ;
46013 void *argp1 = 0 ;
46014 int res1 = 0 ;
46015 int val2 ;
46016 int ecode2 = 0 ;
46017 PyObject * obj0 = 0 ;
46018 PyObject * obj1 = 0 ;
46019 char * kwnames[] = {
46020 (char *) "self",(char *) "proportion", NULL
46021 };
46022
46023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46025 if (!SWIG_IsOK(res1)) {
46026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46027 }
46028 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46029 ecode2 = SWIG_AsVal_int(obj1, &val2);
46030 if (!SWIG_IsOK(ecode2)) {
46031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46032 }
46033 arg2 = static_cast< int >(val2);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
46036 (arg1)->SetProportion(arg2);
46037 wxPyEndAllowThreads(__tstate);
46038 if (PyErr_Occurred()) SWIG_fail;
46039 }
46040 resultobj = SWIG_Py_Void();
46041 return resultobj;
46042 fail:
46043 return NULL;
46044 }
46045
46046
46047 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46048 PyObject *resultobj = 0;
46049 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46050 int result;
46051 void *argp1 = 0 ;
46052 int res1 = 0 ;
46053 PyObject *swig_obj[1] ;
46054
46055 if (!args) SWIG_fail;
46056 swig_obj[0] = args;
46057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 if (!SWIG_IsOK(res1)) {
46059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46060 }
46061 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46062 {
46063 PyThreadState* __tstate = wxPyBeginAllowThreads();
46064 result = (int)(arg1)->GetProportion();
46065 wxPyEndAllowThreads(__tstate);
46066 if (PyErr_Occurred()) SWIG_fail;
46067 }
46068 resultobj = SWIG_From_int(static_cast< int >(result));
46069 return resultobj;
46070 fail:
46071 return NULL;
46072 }
46073
46074
46075 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46076 PyObject *resultobj = 0;
46077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46078 int arg2 ;
46079 void *argp1 = 0 ;
46080 int res1 = 0 ;
46081 int val2 ;
46082 int ecode2 = 0 ;
46083 PyObject * obj0 = 0 ;
46084 PyObject * obj1 = 0 ;
46085 char * kwnames[] = {
46086 (char *) "self",(char *) "flag", NULL
46087 };
46088
46089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46091 if (!SWIG_IsOK(res1)) {
46092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46093 }
46094 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46095 ecode2 = SWIG_AsVal_int(obj1, &val2);
46096 if (!SWIG_IsOK(ecode2)) {
46097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46098 }
46099 arg2 = static_cast< int >(val2);
46100 {
46101 PyThreadState* __tstate = wxPyBeginAllowThreads();
46102 (arg1)->SetFlag(arg2);
46103 wxPyEndAllowThreads(__tstate);
46104 if (PyErr_Occurred()) SWIG_fail;
46105 }
46106 resultobj = SWIG_Py_Void();
46107 return resultobj;
46108 fail:
46109 return NULL;
46110 }
46111
46112
46113 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46114 PyObject *resultobj = 0;
46115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46116 int result;
46117 void *argp1 = 0 ;
46118 int res1 = 0 ;
46119 PyObject *swig_obj[1] ;
46120
46121 if (!args) SWIG_fail;
46122 swig_obj[0] = args;
46123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46124 if (!SWIG_IsOK(res1)) {
46125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46126 }
46127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46128 {
46129 PyThreadState* __tstate = wxPyBeginAllowThreads();
46130 result = (int)(arg1)->GetFlag();
46131 wxPyEndAllowThreads(__tstate);
46132 if (PyErr_Occurred()) SWIG_fail;
46133 }
46134 resultobj = SWIG_From_int(static_cast< int >(result));
46135 return resultobj;
46136 fail:
46137 return NULL;
46138 }
46139
46140
46141 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46142 PyObject *resultobj = 0;
46143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46144 int arg2 ;
46145 void *argp1 = 0 ;
46146 int res1 = 0 ;
46147 int val2 ;
46148 int ecode2 = 0 ;
46149 PyObject * obj0 = 0 ;
46150 PyObject * obj1 = 0 ;
46151 char * kwnames[] = {
46152 (char *) "self",(char *) "border", NULL
46153 };
46154
46155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46157 if (!SWIG_IsOK(res1)) {
46158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46159 }
46160 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46161 ecode2 = SWIG_AsVal_int(obj1, &val2);
46162 if (!SWIG_IsOK(ecode2)) {
46163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46164 }
46165 arg2 = static_cast< int >(val2);
46166 {
46167 PyThreadState* __tstate = wxPyBeginAllowThreads();
46168 (arg1)->SetBorder(arg2);
46169 wxPyEndAllowThreads(__tstate);
46170 if (PyErr_Occurred()) SWIG_fail;
46171 }
46172 resultobj = SWIG_Py_Void();
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46182 int result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46192 }
46193 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = (int)(arg1)->GetBorder();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 resultobj = SWIG_From_int(static_cast< int >(result));
46201 return resultobj;
46202 fail:
46203 return NULL;
46204 }
46205
46206
46207 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46208 PyObject *resultobj = 0;
46209 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46210 wxWindow *result = 0 ;
46211 void *argp1 = 0 ;
46212 int res1 = 0 ;
46213 PyObject *swig_obj[1] ;
46214
46215 if (!args) SWIG_fail;
46216 swig_obj[0] = args;
46217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46218 if (!SWIG_IsOK(res1)) {
46219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46220 }
46221 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46222 {
46223 PyThreadState* __tstate = wxPyBeginAllowThreads();
46224 result = (wxWindow *)(arg1)->GetWindow();
46225 wxPyEndAllowThreads(__tstate);
46226 if (PyErr_Occurred()) SWIG_fail;
46227 }
46228 {
46229 resultobj = wxPyMake_wxObject(result, 0);
46230 }
46231 return resultobj;
46232 fail:
46233 return NULL;
46234 }
46235
46236
46237 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46238 PyObject *resultobj = 0;
46239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46240 wxWindow *arg2 = (wxWindow *) 0 ;
46241 void *argp1 = 0 ;
46242 int res1 = 0 ;
46243 void *argp2 = 0 ;
46244 int res2 = 0 ;
46245 PyObject * obj0 = 0 ;
46246 PyObject * obj1 = 0 ;
46247 char * kwnames[] = {
46248 (char *) "self",(char *) "window", NULL
46249 };
46250
46251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46253 if (!SWIG_IsOK(res1)) {
46254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46255 }
46256 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46258 if (!SWIG_IsOK(res2)) {
46259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46260 }
46261 arg2 = reinterpret_cast< wxWindow * >(argp2);
46262 {
46263 PyThreadState* __tstate = wxPyBeginAllowThreads();
46264 (arg1)->SetWindow(arg2);
46265 wxPyEndAllowThreads(__tstate);
46266 if (PyErr_Occurred()) SWIG_fail;
46267 }
46268 resultobj = SWIG_Py_Void();
46269 return resultobj;
46270 fail:
46271 return NULL;
46272 }
46273
46274
46275 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46276 PyObject *resultobj = 0;
46277 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46278 wxSizer *result = 0 ;
46279 void *argp1 = 0 ;
46280 int res1 = 0 ;
46281 PyObject *swig_obj[1] ;
46282
46283 if (!args) SWIG_fail;
46284 swig_obj[0] = args;
46285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46286 if (!SWIG_IsOK(res1)) {
46287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46288 }
46289 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 result = (wxSizer *)(arg1)->GetSizer();
46293 wxPyEndAllowThreads(__tstate);
46294 if (PyErr_Occurred()) SWIG_fail;
46295 }
46296 {
46297 resultobj = wxPyMake_wxObject(result, (bool)0);
46298 }
46299 return resultobj;
46300 fail:
46301 return NULL;
46302 }
46303
46304
46305 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46306 PyObject *resultobj = 0;
46307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46308 wxSizer *arg2 = (wxSizer *) 0 ;
46309 void *argp1 = 0 ;
46310 int res1 = 0 ;
46311 int res2 = 0 ;
46312 PyObject * obj0 = 0 ;
46313 PyObject * obj1 = 0 ;
46314 char * kwnames[] = {
46315 (char *) "self",(char *) "sizer", NULL
46316 };
46317
46318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46320 if (!SWIG_IsOK(res1)) {
46321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46322 }
46323 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46324 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46325 if (!SWIG_IsOK(res2)) {
46326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46327 }
46328 {
46329 PyThreadState* __tstate = wxPyBeginAllowThreads();
46330 (arg1)->SetSizer(arg2);
46331 wxPyEndAllowThreads(__tstate);
46332 if (PyErr_Occurred()) SWIG_fail;
46333 }
46334 resultobj = SWIG_Py_Void();
46335 return resultobj;
46336 fail:
46337 return NULL;
46338 }
46339
46340
46341 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46342 PyObject *resultobj = 0;
46343 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46344 wxSize *result = 0 ;
46345 void *argp1 = 0 ;
46346 int res1 = 0 ;
46347 PyObject *swig_obj[1] ;
46348
46349 if (!args) SWIG_fail;
46350 swig_obj[0] = args;
46351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46352 if (!SWIG_IsOK(res1)) {
46353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46354 }
46355 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46356 {
46357 PyThreadState* __tstate = wxPyBeginAllowThreads();
46358 {
46359 wxSize const &_result_ref = (arg1)->GetSpacer();
46360 result = (wxSize *) &_result_ref;
46361 }
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46366 return resultobj;
46367 fail:
46368 return NULL;
46369 }
46370
46371
46372 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46373 PyObject *resultobj = 0;
46374 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46375 wxSize *arg2 = 0 ;
46376 void *argp1 = 0 ;
46377 int res1 = 0 ;
46378 wxSize temp2 ;
46379 PyObject * obj0 = 0 ;
46380 PyObject * obj1 = 0 ;
46381 char * kwnames[] = {
46382 (char *) "self",(char *) "size", NULL
46383 };
46384
46385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46387 if (!SWIG_IsOK(res1)) {
46388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46389 }
46390 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46391 {
46392 arg2 = &temp2;
46393 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46394 }
46395 {
46396 PyThreadState* __tstate = wxPyBeginAllowThreads();
46397 (arg1)->SetSpacer((wxSize const &)*arg2);
46398 wxPyEndAllowThreads(__tstate);
46399 if (PyErr_Occurred()) SWIG_fail;
46400 }
46401 resultobj = SWIG_Py_Void();
46402 return resultobj;
46403 fail:
46404 return NULL;
46405 }
46406
46407
46408 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46409 PyObject *resultobj = 0;
46410 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46411 bool arg2 ;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 bool val2 ;
46415 int ecode2 = 0 ;
46416 PyObject * obj0 = 0 ;
46417 PyObject * obj1 = 0 ;
46418 char * kwnames[] = {
46419 (char *) "self",(char *) "show", NULL
46420 };
46421
46422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46424 if (!SWIG_IsOK(res1)) {
46425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46426 }
46427 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46429 if (!SWIG_IsOK(ecode2)) {
46430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46431 }
46432 arg2 = static_cast< bool >(val2);
46433 {
46434 PyThreadState* __tstate = wxPyBeginAllowThreads();
46435 (arg1)->Show(arg2);
46436 wxPyEndAllowThreads(__tstate);
46437 if (PyErr_Occurred()) SWIG_fail;
46438 }
46439 resultobj = SWIG_Py_Void();
46440 return resultobj;
46441 fail:
46442 return NULL;
46443 }
46444
46445
46446 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46447 PyObject *resultobj = 0;
46448 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46449 bool result;
46450 void *argp1 = 0 ;
46451 int res1 = 0 ;
46452 PyObject *swig_obj[1] ;
46453
46454 if (!args) SWIG_fail;
46455 swig_obj[0] = args;
46456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46457 if (!SWIG_IsOK(res1)) {
46458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46459 }
46460 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46461 {
46462 PyThreadState* __tstate = wxPyBeginAllowThreads();
46463 result = (bool)(arg1)->IsShown();
46464 wxPyEndAllowThreads(__tstate);
46465 if (PyErr_Occurred()) SWIG_fail;
46466 }
46467 {
46468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46469 }
46470 return resultobj;
46471 fail:
46472 return NULL;
46473 }
46474
46475
46476 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46477 PyObject *resultobj = 0;
46478 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46479 wxPoint result;
46480 void *argp1 = 0 ;
46481 int res1 = 0 ;
46482 PyObject *swig_obj[1] ;
46483
46484 if (!args) SWIG_fail;
46485 swig_obj[0] = args;
46486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46487 if (!SWIG_IsOK(res1)) {
46488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46489 }
46490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46491 {
46492 PyThreadState* __tstate = wxPyBeginAllowThreads();
46493 result = (arg1)->GetPosition();
46494 wxPyEndAllowThreads(__tstate);
46495 if (PyErr_Occurred()) SWIG_fail;
46496 }
46497 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46505 PyObject *resultobj = 0;
46506 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46507 PyObject *result = 0 ;
46508 void *argp1 = 0 ;
46509 int res1 = 0 ;
46510 PyObject *swig_obj[1] ;
46511
46512 if (!args) SWIG_fail;
46513 swig_obj[0] = args;
46514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46515 if (!SWIG_IsOK(res1)) {
46516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46517 }
46518 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46519 {
46520 PyThreadState* __tstate = wxPyBeginAllowThreads();
46521 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46522 wxPyEndAllowThreads(__tstate);
46523 if (PyErr_Occurred()) SWIG_fail;
46524 }
46525 resultobj = result;
46526 return resultobj;
46527 fail:
46528 return NULL;
46529 }
46530
46531
46532 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46533 PyObject *resultobj = 0;
46534 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46535 PyObject *arg2 = (PyObject *) 0 ;
46536 void *argp1 = 0 ;
46537 int res1 = 0 ;
46538 PyObject * obj0 = 0 ;
46539 PyObject * obj1 = 0 ;
46540 char * kwnames[] = {
46541 (char *) "self",(char *) "userData", NULL
46542 };
46543
46544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46546 if (!SWIG_IsOK(res1)) {
46547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46548 }
46549 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46550 arg2 = obj1;
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 wxSizerItem_SetUserData(arg1,arg2);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 resultobj = SWIG_Py_Void();
46558 return resultobj;
46559 fail:
46560 return NULL;
46561 }
46562
46563
46564 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46565 PyObject *obj;
46566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46567 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46568 return SWIG_Py_Void();
46569 }
46570
46571 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46572 return SWIG_Python_InitShadowInstance(args);
46573 }
46574
46575 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46576 PyObject *resultobj = 0;
46577 wxSizer *arg1 = (wxSizer *) 0 ;
46578 void *argp1 = 0 ;
46579 int res1 = 0 ;
46580 PyObject *swig_obj[1] ;
46581
46582 if (!args) SWIG_fail;
46583 swig_obj[0] = args;
46584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46585 if (!SWIG_IsOK(res1)) {
46586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46587 }
46588 arg1 = reinterpret_cast< wxSizer * >(argp1);
46589 {
46590 PyThreadState* __tstate = wxPyBeginAllowThreads();
46591 delete arg1;
46592
46593 wxPyEndAllowThreads(__tstate);
46594 if (PyErr_Occurred()) SWIG_fail;
46595 }
46596 resultobj = SWIG_Py_Void();
46597 return resultobj;
46598 fail:
46599 return NULL;
46600 }
46601
46602
46603 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46604 PyObject *resultobj = 0;
46605 wxSizer *arg1 = (wxSizer *) 0 ;
46606 PyObject *arg2 = (PyObject *) 0 ;
46607 void *argp1 = 0 ;
46608 int res1 = 0 ;
46609 PyObject * obj0 = 0 ;
46610 PyObject * obj1 = 0 ;
46611 char * kwnames[] = {
46612 (char *) "self",(char *) "_self", NULL
46613 };
46614
46615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46617 if (!SWIG_IsOK(res1)) {
46618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46619 }
46620 arg1 = reinterpret_cast< wxSizer * >(argp1);
46621 arg2 = obj1;
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 wxSizer__setOORInfo(arg1,arg2);
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_Py_Void();
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46636 PyObject *resultobj = 0;
46637 wxSizer *arg1 = (wxSizer *) 0 ;
46638 PyObject *arg2 = (PyObject *) 0 ;
46639 int arg3 = (int) 0 ;
46640 int arg4 = (int) 0 ;
46641 int arg5 = (int) 0 ;
46642 PyObject *arg6 = (PyObject *) NULL ;
46643 wxSizerItem *result = 0 ;
46644 void *argp1 = 0 ;
46645 int res1 = 0 ;
46646 int val3 ;
46647 int ecode3 = 0 ;
46648 int val4 ;
46649 int ecode4 = 0 ;
46650 int val5 ;
46651 int ecode5 = 0 ;
46652 PyObject * obj0 = 0 ;
46653 PyObject * obj1 = 0 ;
46654 PyObject * obj2 = 0 ;
46655 PyObject * obj3 = 0 ;
46656 PyObject * obj4 = 0 ;
46657 PyObject * obj5 = 0 ;
46658 char * kwnames[] = {
46659 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46660 };
46661
46662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46664 if (!SWIG_IsOK(res1)) {
46665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46666 }
46667 arg1 = reinterpret_cast< wxSizer * >(argp1);
46668 arg2 = obj1;
46669 if (obj2) {
46670 ecode3 = SWIG_AsVal_int(obj2, &val3);
46671 if (!SWIG_IsOK(ecode3)) {
46672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46673 }
46674 arg3 = static_cast< int >(val3);
46675 }
46676 if (obj3) {
46677 ecode4 = SWIG_AsVal_int(obj3, &val4);
46678 if (!SWIG_IsOK(ecode4)) {
46679 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46680 }
46681 arg4 = static_cast< int >(val4);
46682 }
46683 if (obj4) {
46684 ecode5 = SWIG_AsVal_int(obj4, &val5);
46685 if (!SWIG_IsOK(ecode5)) {
46686 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46687 }
46688 arg5 = static_cast< int >(val5);
46689 }
46690 if (obj5) {
46691 arg6 = obj5;
46692 }
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxSizer *arg1 = (wxSizer *) 0 ;
46709 int arg2 ;
46710 PyObject *arg3 = (PyObject *) 0 ;
46711 int arg4 = (int) 0 ;
46712 int arg5 = (int) 0 ;
46713 int arg6 = (int) 0 ;
46714 PyObject *arg7 = (PyObject *) NULL ;
46715 wxSizerItem *result = 0 ;
46716 void *argp1 = 0 ;
46717 int res1 = 0 ;
46718 int val2 ;
46719 int ecode2 = 0 ;
46720 int val4 ;
46721 int ecode4 = 0 ;
46722 int val5 ;
46723 int ecode5 = 0 ;
46724 int val6 ;
46725 int ecode6 = 0 ;
46726 PyObject * obj0 = 0 ;
46727 PyObject * obj1 = 0 ;
46728 PyObject * obj2 = 0 ;
46729 PyObject * obj3 = 0 ;
46730 PyObject * obj4 = 0 ;
46731 PyObject * obj5 = 0 ;
46732 PyObject * obj6 = 0 ;
46733 char * kwnames[] = {
46734 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46735 };
46736
46737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46739 if (!SWIG_IsOK(res1)) {
46740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46741 }
46742 arg1 = reinterpret_cast< wxSizer * >(argp1);
46743 ecode2 = SWIG_AsVal_int(obj1, &val2);
46744 if (!SWIG_IsOK(ecode2)) {
46745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46746 }
46747 arg2 = static_cast< int >(val2);
46748 arg3 = obj2;
46749 if (obj3) {
46750 ecode4 = SWIG_AsVal_int(obj3, &val4);
46751 if (!SWIG_IsOK(ecode4)) {
46752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46753 }
46754 arg4 = static_cast< int >(val4);
46755 }
46756 if (obj4) {
46757 ecode5 = SWIG_AsVal_int(obj4, &val5);
46758 if (!SWIG_IsOK(ecode5)) {
46759 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46760 }
46761 arg5 = static_cast< int >(val5);
46762 }
46763 if (obj5) {
46764 ecode6 = SWIG_AsVal_int(obj5, &val6);
46765 if (!SWIG_IsOK(ecode6)) {
46766 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46767 }
46768 arg6 = static_cast< int >(val6);
46769 }
46770 if (obj6) {
46771 arg7 = obj6;
46772 }
46773 {
46774 PyThreadState* __tstate = wxPyBeginAllowThreads();
46775 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46776 wxPyEndAllowThreads(__tstate);
46777 if (PyErr_Occurred()) SWIG_fail;
46778 }
46779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46780 return resultobj;
46781 fail:
46782 return NULL;
46783 }
46784
46785
46786 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46787 PyObject *resultobj = 0;
46788 wxSizer *arg1 = (wxSizer *) 0 ;
46789 PyObject *arg2 = (PyObject *) 0 ;
46790 int arg3 = (int) 0 ;
46791 int arg4 = (int) 0 ;
46792 int arg5 = (int) 0 ;
46793 PyObject *arg6 = (PyObject *) NULL ;
46794 wxSizerItem *result = 0 ;
46795 void *argp1 = 0 ;
46796 int res1 = 0 ;
46797 int val3 ;
46798 int ecode3 = 0 ;
46799 int val4 ;
46800 int ecode4 = 0 ;
46801 int val5 ;
46802 int ecode5 = 0 ;
46803 PyObject * obj0 = 0 ;
46804 PyObject * obj1 = 0 ;
46805 PyObject * obj2 = 0 ;
46806 PyObject * obj3 = 0 ;
46807 PyObject * obj4 = 0 ;
46808 PyObject * obj5 = 0 ;
46809 char * kwnames[] = {
46810 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46811 };
46812
46813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46817 }
46818 arg1 = reinterpret_cast< wxSizer * >(argp1);
46819 arg2 = obj1;
46820 if (obj2) {
46821 ecode3 = SWIG_AsVal_int(obj2, &val3);
46822 if (!SWIG_IsOK(ecode3)) {
46823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46824 }
46825 arg3 = static_cast< int >(val3);
46826 }
46827 if (obj3) {
46828 ecode4 = SWIG_AsVal_int(obj3, &val4);
46829 if (!SWIG_IsOK(ecode4)) {
46830 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46831 }
46832 arg4 = static_cast< int >(val4);
46833 }
46834 if (obj4) {
46835 ecode5 = SWIG_AsVal_int(obj4, &val5);
46836 if (!SWIG_IsOK(ecode5)) {
46837 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46838 }
46839 arg5 = static_cast< int >(val5);
46840 }
46841 if (obj5) {
46842 arg6 = obj5;
46843 }
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46851 return resultobj;
46852 fail:
46853 return NULL;
46854 }
46855
46856
46857 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46858 PyObject *resultobj = 0;
46859 wxSizer *arg1 = (wxSizer *) 0 ;
46860 PyObject *arg2 = (PyObject *) 0 ;
46861 bool result;
46862 void *argp1 = 0 ;
46863 int res1 = 0 ;
46864 PyObject * obj0 = 0 ;
46865 PyObject * obj1 = 0 ;
46866 char * kwnames[] = {
46867 (char *) "self",(char *) "item", NULL
46868 };
46869
46870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46872 if (!SWIG_IsOK(res1)) {
46873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46874 }
46875 arg1 = reinterpret_cast< wxSizer * >(argp1);
46876 arg2 = obj1;
46877 {
46878 PyThreadState* __tstate = wxPyBeginAllowThreads();
46879 result = (bool)wxSizer_Remove(arg1,arg2);
46880 wxPyEndAllowThreads(__tstate);
46881 if (PyErr_Occurred()) SWIG_fail;
46882 }
46883 {
46884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46885 }
46886 return resultobj;
46887 fail:
46888 return NULL;
46889 }
46890
46891
46892 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46893 PyObject *resultobj = 0;
46894 wxSizer *arg1 = (wxSizer *) 0 ;
46895 PyObject *arg2 = (PyObject *) 0 ;
46896 bool result;
46897 void *argp1 = 0 ;
46898 int res1 = 0 ;
46899 PyObject * obj0 = 0 ;
46900 PyObject * obj1 = 0 ;
46901 char * kwnames[] = {
46902 (char *) "self",(char *) "item", NULL
46903 };
46904
46905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46907 if (!SWIG_IsOK(res1)) {
46908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46909 }
46910 arg1 = reinterpret_cast< wxSizer * >(argp1);
46911 arg2 = obj1;
46912 {
46913 PyThreadState* __tstate = wxPyBeginAllowThreads();
46914 result = (bool)wxSizer_Detach(arg1,arg2);
46915 wxPyEndAllowThreads(__tstate);
46916 if (PyErr_Occurred()) SWIG_fail;
46917 }
46918 {
46919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46920 }
46921 return resultobj;
46922 fail:
46923 return NULL;
46924 }
46925
46926
46927 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46928 PyObject *resultobj = 0;
46929 wxSizer *arg1 = (wxSizer *) 0 ;
46930 PyObject *arg2 = (PyObject *) 0 ;
46931 wxSizerItem *result = 0 ;
46932 void *argp1 = 0 ;
46933 int res1 = 0 ;
46934 PyObject * obj0 = 0 ;
46935 PyObject * obj1 = 0 ;
46936 char * kwnames[] = {
46937 (char *) "self",(char *) "item", NULL
46938 };
46939
46940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46942 if (!SWIG_IsOK(res1)) {
46943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46944 }
46945 arg1 = reinterpret_cast< wxSizer * >(argp1);
46946 arg2 = obj1;
46947 {
46948 PyThreadState* __tstate = wxPyBeginAllowThreads();
46949 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46950 wxPyEndAllowThreads(__tstate);
46951 if (PyErr_Occurred()) SWIG_fail;
46952 }
46953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46954 return resultobj;
46955 fail:
46956 return NULL;
46957 }
46958
46959
46960 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46961 PyObject *resultobj = 0;
46962 wxSizer *arg1 = (wxSizer *) 0 ;
46963 PyObject *arg2 = (PyObject *) 0 ;
46964 wxSize *arg3 = 0 ;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 wxSize temp3 ;
46968 PyObject * obj0 = 0 ;
46969 PyObject * obj1 = 0 ;
46970 PyObject * obj2 = 0 ;
46971 char * kwnames[] = {
46972 (char *) "self",(char *) "item",(char *) "size", NULL
46973 };
46974
46975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46977 if (!SWIG_IsOK(res1)) {
46978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46979 }
46980 arg1 = reinterpret_cast< wxSizer * >(argp1);
46981 arg2 = obj1;
46982 {
46983 arg3 = &temp3;
46984 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46985 }
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_Py_Void();
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47000 PyObject *resultobj = 0;
47001 wxSizer *arg1 = (wxSizer *) 0 ;
47002 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47003 wxSizerItem *result = 0 ;
47004 void *argp1 = 0 ;
47005 int res1 = 0 ;
47006 int res2 = 0 ;
47007 PyObject * obj0 = 0 ;
47008 PyObject * obj1 = 0 ;
47009 char * kwnames[] = {
47010 (char *) "self",(char *) "item", NULL
47011 };
47012
47013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47015 if (!SWIG_IsOK(res1)) {
47016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47017 }
47018 arg1 = reinterpret_cast< wxSizer * >(argp1);
47019 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47020 if (!SWIG_IsOK(res2)) {
47021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47022 }
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 result = (wxSizerItem *)(arg1)->Add(arg2);
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47030 return resultobj;
47031 fail:
47032 return NULL;
47033 }
47034
47035
47036 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47037 PyObject *resultobj = 0;
47038 wxSizer *arg1 = (wxSizer *) 0 ;
47039 size_t arg2 ;
47040 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47041 wxSizerItem *result = 0 ;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 size_t val2 ;
47045 int ecode2 = 0 ;
47046 int res3 = 0 ;
47047 PyObject * obj0 = 0 ;
47048 PyObject * obj1 = 0 ;
47049 PyObject * obj2 = 0 ;
47050 char * kwnames[] = {
47051 (char *) "self",(char *) "index",(char *) "item", NULL
47052 };
47053
47054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47056 if (!SWIG_IsOK(res1)) {
47057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47058 }
47059 arg1 = reinterpret_cast< wxSizer * >(argp1);
47060 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47061 if (!SWIG_IsOK(ecode2)) {
47062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47063 }
47064 arg2 = static_cast< size_t >(val2);
47065 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47066 if (!SWIG_IsOK(res3)) {
47067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47068 }
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47083 PyObject *resultobj = 0;
47084 wxSizer *arg1 = (wxSizer *) 0 ;
47085 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47086 wxSizerItem *result = 0 ;
47087 void *argp1 = 0 ;
47088 int res1 = 0 ;
47089 int res2 = 0 ;
47090 PyObject * obj0 = 0 ;
47091 PyObject * obj1 = 0 ;
47092 char * kwnames[] = {
47093 (char *) "self",(char *) "item", NULL
47094 };
47095
47096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47098 if (!SWIG_IsOK(res1)) {
47099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47100 }
47101 arg1 = reinterpret_cast< wxSizer * >(argp1);
47102 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47103 if (!SWIG_IsOK(res2)) {
47104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47105 }
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47120 PyObject *resultobj = 0;
47121 wxSizer *arg1 = (wxSizer *) 0 ;
47122 int arg2 ;
47123 int arg3 ;
47124 int arg4 ;
47125 int arg5 ;
47126 void *argp1 = 0 ;
47127 int res1 = 0 ;
47128 int val2 ;
47129 int ecode2 = 0 ;
47130 int val3 ;
47131 int ecode3 = 0 ;
47132 int val4 ;
47133 int ecode4 = 0 ;
47134 int val5 ;
47135 int ecode5 = 0 ;
47136 PyObject * obj0 = 0 ;
47137 PyObject * obj1 = 0 ;
47138 PyObject * obj2 = 0 ;
47139 PyObject * obj3 = 0 ;
47140 PyObject * obj4 = 0 ;
47141 char * kwnames[] = {
47142 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47143 };
47144
47145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47147 if (!SWIG_IsOK(res1)) {
47148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47149 }
47150 arg1 = reinterpret_cast< wxSizer * >(argp1);
47151 ecode2 = SWIG_AsVal_int(obj1, &val2);
47152 if (!SWIG_IsOK(ecode2)) {
47153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47154 }
47155 arg2 = static_cast< int >(val2);
47156 ecode3 = SWIG_AsVal_int(obj2, &val3);
47157 if (!SWIG_IsOK(ecode3)) {
47158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47159 }
47160 arg3 = static_cast< int >(val3);
47161 ecode4 = SWIG_AsVal_int(obj3, &val4);
47162 if (!SWIG_IsOK(ecode4)) {
47163 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47164 }
47165 arg4 = static_cast< int >(val4);
47166 ecode5 = SWIG_AsVal_int(obj4, &val5);
47167 if (!SWIG_IsOK(ecode5)) {
47168 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47169 }
47170 arg5 = static_cast< int >(val5);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_Py_Void();
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47185 PyObject *resultobj = 0;
47186 wxSizer *arg1 = (wxSizer *) 0 ;
47187 wxSize *arg2 = 0 ;
47188 void *argp1 = 0 ;
47189 int res1 = 0 ;
47190 wxSize temp2 ;
47191 PyObject * obj0 = 0 ;
47192 PyObject * obj1 = 0 ;
47193 char * kwnames[] = {
47194 (char *) "self",(char *) "size", NULL
47195 };
47196
47197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47199 if (!SWIG_IsOK(res1)) {
47200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47201 }
47202 arg1 = reinterpret_cast< wxSizer * >(argp1);
47203 {
47204 arg2 = &temp2;
47205 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47206 }
47207 {
47208 PyThreadState* __tstate = wxPyBeginAllowThreads();
47209 (arg1)->SetMinSize((wxSize const &)*arg2);
47210 wxPyEndAllowThreads(__tstate);
47211 if (PyErr_Occurred()) SWIG_fail;
47212 }
47213 resultobj = SWIG_Py_Void();
47214 return resultobj;
47215 fail:
47216 return NULL;
47217 }
47218
47219
47220 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47221 PyObject *resultobj = 0;
47222 wxSizer *arg1 = (wxSizer *) 0 ;
47223 wxSize result;
47224 void *argp1 = 0 ;
47225 int res1 = 0 ;
47226 PyObject *swig_obj[1] ;
47227
47228 if (!args) SWIG_fail;
47229 swig_obj[0] = args;
47230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47231 if (!SWIG_IsOK(res1)) {
47232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47233 }
47234 arg1 = reinterpret_cast< wxSizer * >(argp1);
47235 {
47236 PyThreadState* __tstate = wxPyBeginAllowThreads();
47237 result = (arg1)->GetSize();
47238 wxPyEndAllowThreads(__tstate);
47239 if (PyErr_Occurred()) SWIG_fail;
47240 }
47241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47242 return resultobj;
47243 fail:
47244 return NULL;
47245 }
47246
47247
47248 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47249 PyObject *resultobj = 0;
47250 wxSizer *arg1 = (wxSizer *) 0 ;
47251 wxPoint result;
47252 void *argp1 = 0 ;
47253 int res1 = 0 ;
47254 PyObject *swig_obj[1] ;
47255
47256 if (!args) SWIG_fail;
47257 swig_obj[0] = args;
47258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47259 if (!SWIG_IsOK(res1)) {
47260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47261 }
47262 arg1 = reinterpret_cast< wxSizer * >(argp1);
47263 {
47264 PyThreadState* __tstate = wxPyBeginAllowThreads();
47265 result = (arg1)->GetPosition();
47266 wxPyEndAllowThreads(__tstate);
47267 if (PyErr_Occurred()) SWIG_fail;
47268 }
47269 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47270 return resultobj;
47271 fail:
47272 return NULL;
47273 }
47274
47275
47276 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47277 PyObject *resultobj = 0;
47278 wxSizer *arg1 = (wxSizer *) 0 ;
47279 wxSize result;
47280 void *argp1 = 0 ;
47281 int res1 = 0 ;
47282 PyObject *swig_obj[1] ;
47283
47284 if (!args) SWIG_fail;
47285 swig_obj[0] = args;
47286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47287 if (!SWIG_IsOK(res1)) {
47288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47289 }
47290 arg1 = reinterpret_cast< wxSizer * >(argp1);
47291 {
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 result = (arg1)->GetMinSize();
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47298 return resultobj;
47299 fail:
47300 return NULL;
47301 }
47302
47303
47304 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47305 PyObject *resultobj = 0;
47306 wxSizer *arg1 = (wxSizer *) 0 ;
47307 void *argp1 = 0 ;
47308 int res1 = 0 ;
47309 PyObject *swig_obj[1] ;
47310
47311 if (!args) SWIG_fail;
47312 swig_obj[0] = args;
47313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47314 if (!SWIG_IsOK(res1)) {
47315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47316 }
47317 arg1 = reinterpret_cast< wxSizer * >(argp1);
47318 {
47319 PyThreadState* __tstate = wxPyBeginAllowThreads();
47320 (arg1)->RecalcSizes();
47321 wxPyEndAllowThreads(__tstate);
47322 if (PyErr_Occurred()) SWIG_fail;
47323 }
47324 resultobj = SWIG_Py_Void();
47325 return resultobj;
47326 fail:
47327 return NULL;
47328 }
47329
47330
47331 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47332 PyObject *resultobj = 0;
47333 wxSizer *arg1 = (wxSizer *) 0 ;
47334 wxSize result;
47335 void *argp1 = 0 ;
47336 int res1 = 0 ;
47337 PyObject *swig_obj[1] ;
47338
47339 if (!args) SWIG_fail;
47340 swig_obj[0] = args;
47341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47342 if (!SWIG_IsOK(res1)) {
47343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47344 }
47345 arg1 = reinterpret_cast< wxSizer * >(argp1);
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 result = (arg1)->CalcMin();
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxSizer *arg1 = (wxSizer *) 0 ;
47362 void *argp1 = 0 ;
47363 int res1 = 0 ;
47364 PyObject *swig_obj[1] ;
47365
47366 if (!args) SWIG_fail;
47367 swig_obj[0] = args;
47368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47369 if (!SWIG_IsOK(res1)) {
47370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47371 }
47372 arg1 = reinterpret_cast< wxSizer * >(argp1);
47373 {
47374 PyThreadState* __tstate = wxPyBeginAllowThreads();
47375 (arg1)->Layout();
47376 wxPyEndAllowThreads(__tstate);
47377 if (PyErr_Occurred()) SWIG_fail;
47378 }
47379 resultobj = SWIG_Py_Void();
47380 return resultobj;
47381 fail:
47382 return NULL;
47383 }
47384
47385
47386 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47387 PyObject *resultobj = 0;
47388 wxSizer *arg1 = (wxSizer *) 0 ;
47389 wxWindow *arg2 = (wxWindow *) 0 ;
47390 wxSize result;
47391 void *argp1 = 0 ;
47392 int res1 = 0 ;
47393 void *argp2 = 0 ;
47394 int res2 = 0 ;
47395 PyObject * obj0 = 0 ;
47396 PyObject * obj1 = 0 ;
47397 char * kwnames[] = {
47398 (char *) "self",(char *) "window", NULL
47399 };
47400
47401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47403 if (!SWIG_IsOK(res1)) {
47404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47405 }
47406 arg1 = reinterpret_cast< wxSizer * >(argp1);
47407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47408 if (!SWIG_IsOK(res2)) {
47409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47410 }
47411 arg2 = reinterpret_cast< wxWindow * >(argp2);
47412 {
47413 PyThreadState* __tstate = wxPyBeginAllowThreads();
47414 result = (arg1)->Fit(arg2);
47415 wxPyEndAllowThreads(__tstate);
47416 if (PyErr_Occurred()) SWIG_fail;
47417 }
47418 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47419 return resultobj;
47420 fail:
47421 return NULL;
47422 }
47423
47424
47425 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47426 PyObject *resultobj = 0;
47427 wxSizer *arg1 = (wxSizer *) 0 ;
47428 wxWindow *arg2 = (wxWindow *) 0 ;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 void *argp2 = 0 ;
47432 int res2 = 0 ;
47433 PyObject * obj0 = 0 ;
47434 PyObject * obj1 = 0 ;
47435 char * kwnames[] = {
47436 (char *) "self",(char *) "window", NULL
47437 };
47438
47439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47441 if (!SWIG_IsOK(res1)) {
47442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47443 }
47444 arg1 = reinterpret_cast< wxSizer * >(argp1);
47445 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47446 if (!SWIG_IsOK(res2)) {
47447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47448 }
47449 arg2 = reinterpret_cast< wxWindow * >(argp2);
47450 {
47451 PyThreadState* __tstate = wxPyBeginAllowThreads();
47452 (arg1)->FitInside(arg2);
47453 wxPyEndAllowThreads(__tstate);
47454 if (PyErr_Occurred()) SWIG_fail;
47455 }
47456 resultobj = SWIG_Py_Void();
47457 return resultobj;
47458 fail:
47459 return NULL;
47460 }
47461
47462
47463 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47464 PyObject *resultobj = 0;
47465 wxSizer *arg1 = (wxSizer *) 0 ;
47466 wxWindow *arg2 = (wxWindow *) 0 ;
47467 void *argp1 = 0 ;
47468 int res1 = 0 ;
47469 void *argp2 = 0 ;
47470 int res2 = 0 ;
47471 PyObject * obj0 = 0 ;
47472 PyObject * obj1 = 0 ;
47473 char * kwnames[] = {
47474 (char *) "self",(char *) "window", NULL
47475 };
47476
47477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47479 if (!SWIG_IsOK(res1)) {
47480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47481 }
47482 arg1 = reinterpret_cast< wxSizer * >(argp1);
47483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47484 if (!SWIG_IsOK(res2)) {
47485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47486 }
47487 arg2 = reinterpret_cast< wxWindow * >(argp2);
47488 {
47489 PyThreadState* __tstate = wxPyBeginAllowThreads();
47490 (arg1)->SetSizeHints(arg2);
47491 wxPyEndAllowThreads(__tstate);
47492 if (PyErr_Occurred()) SWIG_fail;
47493 }
47494 resultobj = SWIG_Py_Void();
47495 return resultobj;
47496 fail:
47497 return NULL;
47498 }
47499
47500
47501 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47502 PyObject *resultobj = 0;
47503 wxSizer *arg1 = (wxSizer *) 0 ;
47504 wxWindow *arg2 = (wxWindow *) 0 ;
47505 void *argp1 = 0 ;
47506 int res1 = 0 ;
47507 void *argp2 = 0 ;
47508 int res2 = 0 ;
47509 PyObject * obj0 = 0 ;
47510 PyObject * obj1 = 0 ;
47511 char * kwnames[] = {
47512 (char *) "self",(char *) "window", NULL
47513 };
47514
47515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47517 if (!SWIG_IsOK(res1)) {
47518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47519 }
47520 arg1 = reinterpret_cast< wxSizer * >(argp1);
47521 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47522 if (!SWIG_IsOK(res2)) {
47523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47524 }
47525 arg2 = reinterpret_cast< wxWindow * >(argp2);
47526 {
47527 PyThreadState* __tstate = wxPyBeginAllowThreads();
47528 (arg1)->SetVirtualSizeHints(arg2);
47529 wxPyEndAllowThreads(__tstate);
47530 if (PyErr_Occurred()) SWIG_fail;
47531 }
47532 resultobj = SWIG_Py_Void();
47533 return resultobj;
47534 fail:
47535 return NULL;
47536 }
47537
47538
47539 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47540 PyObject *resultobj = 0;
47541 wxSizer *arg1 = (wxSizer *) 0 ;
47542 bool arg2 = (bool) false ;
47543 void *argp1 = 0 ;
47544 int res1 = 0 ;
47545 bool val2 ;
47546 int ecode2 = 0 ;
47547 PyObject * obj0 = 0 ;
47548 PyObject * obj1 = 0 ;
47549 char * kwnames[] = {
47550 (char *) "self",(char *) "deleteWindows", NULL
47551 };
47552
47553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47555 if (!SWIG_IsOK(res1)) {
47556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47557 }
47558 arg1 = reinterpret_cast< wxSizer * >(argp1);
47559 if (obj1) {
47560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47561 if (!SWIG_IsOK(ecode2)) {
47562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47563 }
47564 arg2 = static_cast< bool >(val2);
47565 }
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 (arg1)->Clear(arg2);
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 resultobj = SWIG_Py_Void();
47573 return resultobj;
47574 fail:
47575 return NULL;
47576 }
47577
47578
47579 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47580 PyObject *resultobj = 0;
47581 wxSizer *arg1 = (wxSizer *) 0 ;
47582 void *argp1 = 0 ;
47583 int res1 = 0 ;
47584 PyObject *swig_obj[1] ;
47585
47586 if (!args) SWIG_fail;
47587 swig_obj[0] = args;
47588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47589 if (!SWIG_IsOK(res1)) {
47590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47591 }
47592 arg1 = reinterpret_cast< wxSizer * >(argp1);
47593 {
47594 PyThreadState* __tstate = wxPyBeginAllowThreads();
47595 (arg1)->DeleteWindows();
47596 wxPyEndAllowThreads(__tstate);
47597 if (PyErr_Occurred()) SWIG_fail;
47598 }
47599 resultobj = SWIG_Py_Void();
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47607 PyObject *resultobj = 0;
47608 wxSizer *arg1 = (wxSizer *) 0 ;
47609 PyObject *result = 0 ;
47610 void *argp1 = 0 ;
47611 int res1 = 0 ;
47612 PyObject *swig_obj[1] ;
47613
47614 if (!args) SWIG_fail;
47615 swig_obj[0] = args;
47616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47617 if (!SWIG_IsOK(res1)) {
47618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47619 }
47620 arg1 = reinterpret_cast< wxSizer * >(argp1);
47621 {
47622 PyThreadState* __tstate = wxPyBeginAllowThreads();
47623 result = (PyObject *)wxSizer_GetChildren(arg1);
47624 wxPyEndAllowThreads(__tstate);
47625 if (PyErr_Occurred()) SWIG_fail;
47626 }
47627 resultobj = result;
47628 return resultobj;
47629 fail:
47630 return NULL;
47631 }
47632
47633
47634 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47635 PyObject *resultobj = 0;
47636 wxSizer *arg1 = (wxSizer *) 0 ;
47637 PyObject *arg2 = (PyObject *) 0 ;
47638 bool arg3 = (bool) true ;
47639 bool arg4 = (bool) false ;
47640 bool result;
47641 void *argp1 = 0 ;
47642 int res1 = 0 ;
47643 bool val3 ;
47644 int ecode3 = 0 ;
47645 bool val4 ;
47646 int ecode4 = 0 ;
47647 PyObject * obj0 = 0 ;
47648 PyObject * obj1 = 0 ;
47649 PyObject * obj2 = 0 ;
47650 PyObject * obj3 = 0 ;
47651 char * kwnames[] = {
47652 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47653 };
47654
47655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47657 if (!SWIG_IsOK(res1)) {
47658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47659 }
47660 arg1 = reinterpret_cast< wxSizer * >(argp1);
47661 arg2 = obj1;
47662 if (obj2) {
47663 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47664 if (!SWIG_IsOK(ecode3)) {
47665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47666 }
47667 arg3 = static_cast< bool >(val3);
47668 }
47669 if (obj3) {
47670 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47671 if (!SWIG_IsOK(ecode4)) {
47672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47673 }
47674 arg4 = static_cast< bool >(val4);
47675 }
47676 {
47677 PyThreadState* __tstate = wxPyBeginAllowThreads();
47678 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47679 wxPyEndAllowThreads(__tstate);
47680 if (PyErr_Occurred()) SWIG_fail;
47681 }
47682 {
47683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47684 }
47685 return resultobj;
47686 fail:
47687 return NULL;
47688 }
47689
47690
47691 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47692 PyObject *resultobj = 0;
47693 wxSizer *arg1 = (wxSizer *) 0 ;
47694 PyObject *arg2 = (PyObject *) 0 ;
47695 bool result;
47696 void *argp1 = 0 ;
47697 int res1 = 0 ;
47698 PyObject * obj0 = 0 ;
47699 PyObject * obj1 = 0 ;
47700 char * kwnames[] = {
47701 (char *) "self",(char *) "item", NULL
47702 };
47703
47704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47706 if (!SWIG_IsOK(res1)) {
47707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47708 }
47709 arg1 = reinterpret_cast< wxSizer * >(argp1);
47710 arg2 = obj1;
47711 {
47712 PyThreadState* __tstate = wxPyBeginAllowThreads();
47713 result = (bool)wxSizer_IsShown(arg1,arg2);
47714 wxPyEndAllowThreads(__tstate);
47715 if (PyErr_Occurred()) SWIG_fail;
47716 }
47717 {
47718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47719 }
47720 return resultobj;
47721 fail:
47722 return NULL;
47723 }
47724
47725
47726 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47727 PyObject *resultobj = 0;
47728 wxSizer *arg1 = (wxSizer *) 0 ;
47729 bool arg2 ;
47730 void *argp1 = 0 ;
47731 int res1 = 0 ;
47732 bool val2 ;
47733 int ecode2 = 0 ;
47734 PyObject * obj0 = 0 ;
47735 PyObject * obj1 = 0 ;
47736 char * kwnames[] = {
47737 (char *) "self",(char *) "show", NULL
47738 };
47739
47740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47742 if (!SWIG_IsOK(res1)) {
47743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47744 }
47745 arg1 = reinterpret_cast< wxSizer * >(argp1);
47746 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47747 if (!SWIG_IsOK(ecode2)) {
47748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47749 }
47750 arg2 = static_cast< bool >(val2);
47751 {
47752 PyThreadState* __tstate = wxPyBeginAllowThreads();
47753 (arg1)->ShowItems(arg2);
47754 wxPyEndAllowThreads(__tstate);
47755 if (PyErr_Occurred()) SWIG_fail;
47756 }
47757 resultobj = SWIG_Py_Void();
47758 return resultobj;
47759 fail:
47760 return NULL;
47761 }
47762
47763
47764 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47765 PyObject *obj;
47766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47767 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47768 return SWIG_Py_Void();
47769 }
47770
47771 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47772 PyObject *resultobj = 0;
47773 wxPySizer *result = 0 ;
47774
47775 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47776 {
47777 PyThreadState* __tstate = wxPyBeginAllowThreads();
47778 result = (wxPySizer *)new wxPySizer();
47779 wxPyEndAllowThreads(__tstate);
47780 if (PyErr_Occurred()) SWIG_fail;
47781 }
47782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47783 return resultobj;
47784 fail:
47785 return NULL;
47786 }
47787
47788
47789 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47790 PyObject *resultobj = 0;
47791 wxPySizer *arg1 = (wxPySizer *) 0 ;
47792 PyObject *arg2 = (PyObject *) 0 ;
47793 PyObject *arg3 = (PyObject *) 0 ;
47794 void *argp1 = 0 ;
47795 int res1 = 0 ;
47796 PyObject * obj0 = 0 ;
47797 PyObject * obj1 = 0 ;
47798 PyObject * obj2 = 0 ;
47799 char * kwnames[] = {
47800 (char *) "self",(char *) "self",(char *) "_class", NULL
47801 };
47802
47803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47805 if (!SWIG_IsOK(res1)) {
47806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47807 }
47808 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47809 arg2 = obj1;
47810 arg3 = obj2;
47811 {
47812 PyThreadState* __tstate = wxPyBeginAllowThreads();
47813 (arg1)->_setCallbackInfo(arg2,arg3);
47814 wxPyEndAllowThreads(__tstate);
47815 if (PyErr_Occurred()) SWIG_fail;
47816 }
47817 resultobj = SWIG_Py_Void();
47818 return resultobj;
47819 fail:
47820 return NULL;
47821 }
47822
47823
47824 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47825 PyObject *obj;
47826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47827 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47828 return SWIG_Py_Void();
47829 }
47830
47831 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47832 return SWIG_Python_InitShadowInstance(args);
47833 }
47834
47835 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47836 PyObject *resultobj = 0;
47837 int arg1 = (int) wxHORIZONTAL ;
47838 wxBoxSizer *result = 0 ;
47839 int val1 ;
47840 int ecode1 = 0 ;
47841 PyObject * obj0 = 0 ;
47842 char * kwnames[] = {
47843 (char *) "orient", NULL
47844 };
47845
47846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47847 if (obj0) {
47848 ecode1 = SWIG_AsVal_int(obj0, &val1);
47849 if (!SWIG_IsOK(ecode1)) {
47850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47851 }
47852 arg1 = static_cast< int >(val1);
47853 }
47854 {
47855 PyThreadState* __tstate = wxPyBeginAllowThreads();
47856 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47857 wxPyEndAllowThreads(__tstate);
47858 if (PyErr_Occurred()) SWIG_fail;
47859 }
47860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47861 return resultobj;
47862 fail:
47863 return NULL;
47864 }
47865
47866
47867 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47868 PyObject *resultobj = 0;
47869 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47870 int result;
47871 void *argp1 = 0 ;
47872 int res1 = 0 ;
47873 PyObject *swig_obj[1] ;
47874
47875 if (!args) SWIG_fail;
47876 swig_obj[0] = args;
47877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47878 if (!SWIG_IsOK(res1)) {
47879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47880 }
47881 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47882 {
47883 PyThreadState* __tstate = wxPyBeginAllowThreads();
47884 result = (int)(arg1)->GetOrientation();
47885 wxPyEndAllowThreads(__tstate);
47886 if (PyErr_Occurred()) SWIG_fail;
47887 }
47888 resultobj = SWIG_From_int(static_cast< int >(result));
47889 return resultobj;
47890 fail:
47891 return NULL;
47892 }
47893
47894
47895 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47896 PyObject *resultobj = 0;
47897 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47898 int arg2 ;
47899 void *argp1 = 0 ;
47900 int res1 = 0 ;
47901 int val2 ;
47902 int ecode2 = 0 ;
47903 PyObject * obj0 = 0 ;
47904 PyObject * obj1 = 0 ;
47905 char * kwnames[] = {
47906 (char *) "self",(char *) "orient", NULL
47907 };
47908
47909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47911 if (!SWIG_IsOK(res1)) {
47912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47913 }
47914 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47915 ecode2 = SWIG_AsVal_int(obj1, &val2);
47916 if (!SWIG_IsOK(ecode2)) {
47917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47918 }
47919 arg2 = static_cast< int >(val2);
47920 {
47921 PyThreadState* __tstate = wxPyBeginAllowThreads();
47922 (arg1)->SetOrientation(arg2);
47923 wxPyEndAllowThreads(__tstate);
47924 if (PyErr_Occurred()) SWIG_fail;
47925 }
47926 resultobj = SWIG_Py_Void();
47927 return resultobj;
47928 fail:
47929 return NULL;
47930 }
47931
47932
47933 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47934 PyObject *obj;
47935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47936 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47937 return SWIG_Py_Void();
47938 }
47939
47940 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47941 return SWIG_Python_InitShadowInstance(args);
47942 }
47943
47944 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47945 PyObject *resultobj = 0;
47946 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47947 int arg2 = (int) wxHORIZONTAL ;
47948 wxStaticBoxSizer *result = 0 ;
47949 void *argp1 = 0 ;
47950 int res1 = 0 ;
47951 int val2 ;
47952 int ecode2 = 0 ;
47953 PyObject * obj0 = 0 ;
47954 PyObject * obj1 = 0 ;
47955 char * kwnames[] = {
47956 (char *) "box",(char *) "orient", NULL
47957 };
47958
47959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47961 if (!SWIG_IsOK(res1)) {
47962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47963 }
47964 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47965 if (obj1) {
47966 ecode2 = SWIG_AsVal_int(obj1, &val2);
47967 if (!SWIG_IsOK(ecode2)) {
47968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47969 }
47970 arg2 = static_cast< int >(val2);
47971 }
47972 {
47973 PyThreadState* __tstate = wxPyBeginAllowThreads();
47974 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47975 wxPyEndAllowThreads(__tstate);
47976 if (PyErr_Occurred()) SWIG_fail;
47977 }
47978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47979 return resultobj;
47980 fail:
47981 return NULL;
47982 }
47983
47984
47985 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47986 PyObject *resultobj = 0;
47987 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47988 wxStaticBox *result = 0 ;
47989 void *argp1 = 0 ;
47990 int res1 = 0 ;
47991 PyObject *swig_obj[1] ;
47992
47993 if (!args) SWIG_fail;
47994 swig_obj[0] = args;
47995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47996 if (!SWIG_IsOK(res1)) {
47997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47998 }
47999 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 result = (wxStaticBox *)(arg1)->GetStaticBox();
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 {
48007 resultobj = wxPyMake_wxObject(result, (bool)0);
48008 }
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48016 PyObject *obj;
48017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48018 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48019 return SWIG_Py_Void();
48020 }
48021
48022 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48023 return SWIG_Python_InitShadowInstance(args);
48024 }
48025
48026 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48027 PyObject *resultobj = 0;
48028 int arg1 = (int) 1 ;
48029 int arg2 = (int) 0 ;
48030 int arg3 = (int) 0 ;
48031 int arg4 = (int) 0 ;
48032 wxGridSizer *result = 0 ;
48033 int val1 ;
48034 int ecode1 = 0 ;
48035 int val2 ;
48036 int ecode2 = 0 ;
48037 int val3 ;
48038 int ecode3 = 0 ;
48039 int val4 ;
48040 int ecode4 = 0 ;
48041 PyObject * obj0 = 0 ;
48042 PyObject * obj1 = 0 ;
48043 PyObject * obj2 = 0 ;
48044 PyObject * obj3 = 0 ;
48045 char * kwnames[] = {
48046 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48047 };
48048
48049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48050 if (obj0) {
48051 ecode1 = SWIG_AsVal_int(obj0, &val1);
48052 if (!SWIG_IsOK(ecode1)) {
48053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48054 }
48055 arg1 = static_cast< int >(val1);
48056 }
48057 if (obj1) {
48058 ecode2 = SWIG_AsVal_int(obj1, &val2);
48059 if (!SWIG_IsOK(ecode2)) {
48060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48061 }
48062 arg2 = static_cast< int >(val2);
48063 }
48064 if (obj2) {
48065 ecode3 = SWIG_AsVal_int(obj2, &val3);
48066 if (!SWIG_IsOK(ecode3)) {
48067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48068 }
48069 arg3 = static_cast< int >(val3);
48070 }
48071 if (obj3) {
48072 ecode4 = SWIG_AsVal_int(obj3, &val4);
48073 if (!SWIG_IsOK(ecode4)) {
48074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48075 }
48076 arg4 = static_cast< int >(val4);
48077 }
48078 {
48079 PyThreadState* __tstate = wxPyBeginAllowThreads();
48080 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48081 wxPyEndAllowThreads(__tstate);
48082 if (PyErr_Occurred()) SWIG_fail;
48083 }
48084 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48085 return resultobj;
48086 fail:
48087 return NULL;
48088 }
48089
48090
48091 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48092 PyObject *resultobj = 0;
48093 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48094 int arg2 ;
48095 void *argp1 = 0 ;
48096 int res1 = 0 ;
48097 int val2 ;
48098 int ecode2 = 0 ;
48099 PyObject * obj0 = 0 ;
48100 PyObject * obj1 = 0 ;
48101 char * kwnames[] = {
48102 (char *) "self",(char *) "cols", NULL
48103 };
48104
48105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48107 if (!SWIG_IsOK(res1)) {
48108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48109 }
48110 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48111 ecode2 = SWIG_AsVal_int(obj1, &val2);
48112 if (!SWIG_IsOK(ecode2)) {
48113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48114 }
48115 arg2 = static_cast< int >(val2);
48116 {
48117 PyThreadState* __tstate = wxPyBeginAllowThreads();
48118 (arg1)->SetCols(arg2);
48119 wxPyEndAllowThreads(__tstate);
48120 if (PyErr_Occurred()) SWIG_fail;
48121 }
48122 resultobj = SWIG_Py_Void();
48123 return resultobj;
48124 fail:
48125 return NULL;
48126 }
48127
48128
48129 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48130 PyObject *resultobj = 0;
48131 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48132 int arg2 ;
48133 void *argp1 = 0 ;
48134 int res1 = 0 ;
48135 int val2 ;
48136 int ecode2 = 0 ;
48137 PyObject * obj0 = 0 ;
48138 PyObject * obj1 = 0 ;
48139 char * kwnames[] = {
48140 (char *) "self",(char *) "rows", NULL
48141 };
48142
48143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48145 if (!SWIG_IsOK(res1)) {
48146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48147 }
48148 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48149 ecode2 = SWIG_AsVal_int(obj1, &val2);
48150 if (!SWIG_IsOK(ecode2)) {
48151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48152 }
48153 arg2 = static_cast< int >(val2);
48154 {
48155 PyThreadState* __tstate = wxPyBeginAllowThreads();
48156 (arg1)->SetRows(arg2);
48157 wxPyEndAllowThreads(__tstate);
48158 if (PyErr_Occurred()) SWIG_fail;
48159 }
48160 resultobj = SWIG_Py_Void();
48161 return resultobj;
48162 fail:
48163 return NULL;
48164 }
48165
48166
48167 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48168 PyObject *resultobj = 0;
48169 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48170 int arg2 ;
48171 void *argp1 = 0 ;
48172 int res1 = 0 ;
48173 int val2 ;
48174 int ecode2 = 0 ;
48175 PyObject * obj0 = 0 ;
48176 PyObject * obj1 = 0 ;
48177 char * kwnames[] = {
48178 (char *) "self",(char *) "gap", NULL
48179 };
48180
48181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48183 if (!SWIG_IsOK(res1)) {
48184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48185 }
48186 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48187 ecode2 = SWIG_AsVal_int(obj1, &val2);
48188 if (!SWIG_IsOK(ecode2)) {
48189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48190 }
48191 arg2 = static_cast< int >(val2);
48192 {
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 (arg1)->SetVGap(arg2);
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 resultobj = SWIG_Py_Void();
48199 return resultobj;
48200 fail:
48201 return NULL;
48202 }
48203
48204
48205 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48206 PyObject *resultobj = 0;
48207 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48208 int arg2 ;
48209 void *argp1 = 0 ;
48210 int res1 = 0 ;
48211 int val2 ;
48212 int ecode2 = 0 ;
48213 PyObject * obj0 = 0 ;
48214 PyObject * obj1 = 0 ;
48215 char * kwnames[] = {
48216 (char *) "self",(char *) "gap", NULL
48217 };
48218
48219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48221 if (!SWIG_IsOK(res1)) {
48222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48223 }
48224 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48225 ecode2 = SWIG_AsVal_int(obj1, &val2);
48226 if (!SWIG_IsOK(ecode2)) {
48227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48228 }
48229 arg2 = static_cast< int >(val2);
48230 {
48231 PyThreadState* __tstate = wxPyBeginAllowThreads();
48232 (arg1)->SetHGap(arg2);
48233 wxPyEndAllowThreads(__tstate);
48234 if (PyErr_Occurred()) SWIG_fail;
48235 }
48236 resultobj = SWIG_Py_Void();
48237 return resultobj;
48238 fail:
48239 return NULL;
48240 }
48241
48242
48243 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48244 PyObject *resultobj = 0;
48245 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48246 int result;
48247 void *argp1 = 0 ;
48248 int res1 = 0 ;
48249 PyObject *swig_obj[1] ;
48250
48251 if (!args) SWIG_fail;
48252 swig_obj[0] = args;
48253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48254 if (!SWIG_IsOK(res1)) {
48255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48256 }
48257 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48258 {
48259 PyThreadState* __tstate = wxPyBeginAllowThreads();
48260 result = (int)(arg1)->GetCols();
48261 wxPyEndAllowThreads(__tstate);
48262 if (PyErr_Occurred()) SWIG_fail;
48263 }
48264 resultobj = SWIG_From_int(static_cast< int >(result));
48265 return resultobj;
48266 fail:
48267 return NULL;
48268 }
48269
48270
48271 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48272 PyObject *resultobj = 0;
48273 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48274 int result;
48275 void *argp1 = 0 ;
48276 int res1 = 0 ;
48277 PyObject *swig_obj[1] ;
48278
48279 if (!args) SWIG_fail;
48280 swig_obj[0] = args;
48281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48282 if (!SWIG_IsOK(res1)) {
48283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48284 }
48285 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48286 {
48287 PyThreadState* __tstate = wxPyBeginAllowThreads();
48288 result = (int)(arg1)->GetRows();
48289 wxPyEndAllowThreads(__tstate);
48290 if (PyErr_Occurred()) SWIG_fail;
48291 }
48292 resultobj = SWIG_From_int(static_cast< int >(result));
48293 return resultobj;
48294 fail:
48295 return NULL;
48296 }
48297
48298
48299 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48300 PyObject *resultobj = 0;
48301 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48302 int result;
48303 void *argp1 = 0 ;
48304 int res1 = 0 ;
48305 PyObject *swig_obj[1] ;
48306
48307 if (!args) SWIG_fail;
48308 swig_obj[0] = args;
48309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48310 if (!SWIG_IsOK(res1)) {
48311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48312 }
48313 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48314 {
48315 PyThreadState* __tstate = wxPyBeginAllowThreads();
48316 result = (int)(arg1)->GetVGap();
48317 wxPyEndAllowThreads(__tstate);
48318 if (PyErr_Occurred()) SWIG_fail;
48319 }
48320 resultobj = SWIG_From_int(static_cast< int >(result));
48321 return resultobj;
48322 fail:
48323 return NULL;
48324 }
48325
48326
48327 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *resultobj = 0;
48329 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48330 int result;
48331 void *argp1 = 0 ;
48332 int res1 = 0 ;
48333 PyObject *swig_obj[1] ;
48334
48335 if (!args) SWIG_fail;
48336 swig_obj[0] = args;
48337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48340 }
48341 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 result = (int)(arg1)->GetHGap();
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 resultobj = SWIG_From_int(static_cast< int >(result));
48349 return resultobj;
48350 fail:
48351 return NULL;
48352 }
48353
48354
48355 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48356 PyObject *obj;
48357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48358 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48359 return SWIG_Py_Void();
48360 }
48361
48362 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48363 return SWIG_Python_InitShadowInstance(args);
48364 }
48365
48366 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48367 PyObject *resultobj = 0;
48368 int arg1 = (int) 1 ;
48369 int arg2 = (int) 0 ;
48370 int arg3 = (int) 0 ;
48371 int arg4 = (int) 0 ;
48372 wxFlexGridSizer *result = 0 ;
48373 int val1 ;
48374 int ecode1 = 0 ;
48375 int val2 ;
48376 int ecode2 = 0 ;
48377 int val3 ;
48378 int ecode3 = 0 ;
48379 int val4 ;
48380 int ecode4 = 0 ;
48381 PyObject * obj0 = 0 ;
48382 PyObject * obj1 = 0 ;
48383 PyObject * obj2 = 0 ;
48384 PyObject * obj3 = 0 ;
48385 char * kwnames[] = {
48386 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48387 };
48388
48389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48390 if (obj0) {
48391 ecode1 = SWIG_AsVal_int(obj0, &val1);
48392 if (!SWIG_IsOK(ecode1)) {
48393 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48394 }
48395 arg1 = static_cast< int >(val1);
48396 }
48397 if (obj1) {
48398 ecode2 = SWIG_AsVal_int(obj1, &val2);
48399 if (!SWIG_IsOK(ecode2)) {
48400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48401 }
48402 arg2 = static_cast< int >(val2);
48403 }
48404 if (obj2) {
48405 ecode3 = SWIG_AsVal_int(obj2, &val3);
48406 if (!SWIG_IsOK(ecode3)) {
48407 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48408 }
48409 arg3 = static_cast< int >(val3);
48410 }
48411 if (obj3) {
48412 ecode4 = SWIG_AsVal_int(obj3, &val4);
48413 if (!SWIG_IsOK(ecode4)) {
48414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48415 }
48416 arg4 = static_cast< int >(val4);
48417 }
48418 {
48419 PyThreadState* __tstate = wxPyBeginAllowThreads();
48420 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48421 wxPyEndAllowThreads(__tstate);
48422 if (PyErr_Occurred()) SWIG_fail;
48423 }
48424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48425 return resultobj;
48426 fail:
48427 return NULL;
48428 }
48429
48430
48431 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48432 PyObject *resultobj = 0;
48433 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48434 size_t arg2 ;
48435 int arg3 = (int) 0 ;
48436 void *argp1 = 0 ;
48437 int res1 = 0 ;
48438 size_t val2 ;
48439 int ecode2 = 0 ;
48440 int val3 ;
48441 int ecode3 = 0 ;
48442 PyObject * obj0 = 0 ;
48443 PyObject * obj1 = 0 ;
48444 PyObject * obj2 = 0 ;
48445 char * kwnames[] = {
48446 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48447 };
48448
48449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48451 if (!SWIG_IsOK(res1)) {
48452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48453 }
48454 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48455 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48456 if (!SWIG_IsOK(ecode2)) {
48457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48458 }
48459 arg2 = static_cast< size_t >(val2);
48460 if (obj2) {
48461 ecode3 = SWIG_AsVal_int(obj2, &val3);
48462 if (!SWIG_IsOK(ecode3)) {
48463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48464 }
48465 arg3 = static_cast< int >(val3);
48466 }
48467 {
48468 PyThreadState* __tstate = wxPyBeginAllowThreads();
48469 (arg1)->AddGrowableRow(arg2,arg3);
48470 wxPyEndAllowThreads(__tstate);
48471 if (PyErr_Occurred()) SWIG_fail;
48472 }
48473 resultobj = SWIG_Py_Void();
48474 return resultobj;
48475 fail:
48476 return NULL;
48477 }
48478
48479
48480 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48481 PyObject *resultobj = 0;
48482 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48483 size_t arg2 ;
48484 void *argp1 = 0 ;
48485 int res1 = 0 ;
48486 size_t val2 ;
48487 int ecode2 = 0 ;
48488 PyObject * obj0 = 0 ;
48489 PyObject * obj1 = 0 ;
48490 char * kwnames[] = {
48491 (char *) "self",(char *) "idx", NULL
48492 };
48493
48494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48496 if (!SWIG_IsOK(res1)) {
48497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48498 }
48499 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48500 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48501 if (!SWIG_IsOK(ecode2)) {
48502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48503 }
48504 arg2 = static_cast< size_t >(val2);
48505 {
48506 PyThreadState* __tstate = wxPyBeginAllowThreads();
48507 (arg1)->RemoveGrowableRow(arg2);
48508 wxPyEndAllowThreads(__tstate);
48509 if (PyErr_Occurred()) SWIG_fail;
48510 }
48511 resultobj = SWIG_Py_Void();
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48521 size_t arg2 ;
48522 int arg3 = (int) 0 ;
48523 void *argp1 = 0 ;
48524 int res1 = 0 ;
48525 size_t val2 ;
48526 int ecode2 = 0 ;
48527 int val3 ;
48528 int ecode3 = 0 ;
48529 PyObject * obj0 = 0 ;
48530 PyObject * obj1 = 0 ;
48531 PyObject * obj2 = 0 ;
48532 char * kwnames[] = {
48533 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48534 };
48535
48536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48538 if (!SWIG_IsOK(res1)) {
48539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48540 }
48541 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48542 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48543 if (!SWIG_IsOK(ecode2)) {
48544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48545 }
48546 arg2 = static_cast< size_t >(val2);
48547 if (obj2) {
48548 ecode3 = SWIG_AsVal_int(obj2, &val3);
48549 if (!SWIG_IsOK(ecode3)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48551 }
48552 arg3 = static_cast< int >(val3);
48553 }
48554 {
48555 PyThreadState* __tstate = wxPyBeginAllowThreads();
48556 (arg1)->AddGrowableCol(arg2,arg3);
48557 wxPyEndAllowThreads(__tstate);
48558 if (PyErr_Occurred()) SWIG_fail;
48559 }
48560 resultobj = SWIG_Py_Void();
48561 return resultobj;
48562 fail:
48563 return NULL;
48564 }
48565
48566
48567 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48568 PyObject *resultobj = 0;
48569 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48570 size_t arg2 ;
48571 void *argp1 = 0 ;
48572 int res1 = 0 ;
48573 size_t val2 ;
48574 int ecode2 = 0 ;
48575 PyObject * obj0 = 0 ;
48576 PyObject * obj1 = 0 ;
48577 char * kwnames[] = {
48578 (char *) "self",(char *) "idx", NULL
48579 };
48580
48581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48583 if (!SWIG_IsOK(res1)) {
48584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48585 }
48586 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48587 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48588 if (!SWIG_IsOK(ecode2)) {
48589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48590 }
48591 arg2 = static_cast< size_t >(val2);
48592 {
48593 PyThreadState* __tstate = wxPyBeginAllowThreads();
48594 (arg1)->RemoveGrowableCol(arg2);
48595 wxPyEndAllowThreads(__tstate);
48596 if (PyErr_Occurred()) SWIG_fail;
48597 }
48598 resultobj = SWIG_Py_Void();
48599 return resultobj;
48600 fail:
48601 return NULL;
48602 }
48603
48604
48605 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48606 PyObject *resultobj = 0;
48607 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48608 int arg2 ;
48609 void *argp1 = 0 ;
48610 int res1 = 0 ;
48611 int val2 ;
48612 int ecode2 = 0 ;
48613 PyObject * obj0 = 0 ;
48614 PyObject * obj1 = 0 ;
48615 char * kwnames[] = {
48616 (char *) "self",(char *) "direction", NULL
48617 };
48618
48619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48621 if (!SWIG_IsOK(res1)) {
48622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48623 }
48624 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48625 ecode2 = SWIG_AsVal_int(obj1, &val2);
48626 if (!SWIG_IsOK(ecode2)) {
48627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48628 }
48629 arg2 = static_cast< int >(val2);
48630 {
48631 PyThreadState* __tstate = wxPyBeginAllowThreads();
48632 (arg1)->SetFlexibleDirection(arg2);
48633 wxPyEndAllowThreads(__tstate);
48634 if (PyErr_Occurred()) SWIG_fail;
48635 }
48636 resultobj = SWIG_Py_Void();
48637 return resultobj;
48638 fail:
48639 return NULL;
48640 }
48641
48642
48643 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48644 PyObject *resultobj = 0;
48645 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48646 int result;
48647 void *argp1 = 0 ;
48648 int res1 = 0 ;
48649 PyObject *swig_obj[1] ;
48650
48651 if (!args) SWIG_fail;
48652 swig_obj[0] = args;
48653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48654 if (!SWIG_IsOK(res1)) {
48655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48656 }
48657 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48658 {
48659 PyThreadState* __tstate = wxPyBeginAllowThreads();
48660 result = (int)(arg1)->GetFlexibleDirection();
48661 wxPyEndAllowThreads(__tstate);
48662 if (PyErr_Occurred()) SWIG_fail;
48663 }
48664 resultobj = SWIG_From_int(static_cast< int >(result));
48665 return resultobj;
48666 fail:
48667 return NULL;
48668 }
48669
48670
48671 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48672 PyObject *resultobj = 0;
48673 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48674 wxFlexSizerGrowMode arg2 ;
48675 void *argp1 = 0 ;
48676 int res1 = 0 ;
48677 int val2 ;
48678 int ecode2 = 0 ;
48679 PyObject * obj0 = 0 ;
48680 PyObject * obj1 = 0 ;
48681 char * kwnames[] = {
48682 (char *) "self",(char *) "mode", NULL
48683 };
48684
48685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48687 if (!SWIG_IsOK(res1)) {
48688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48689 }
48690 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48691 ecode2 = SWIG_AsVal_int(obj1, &val2);
48692 if (!SWIG_IsOK(ecode2)) {
48693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48694 }
48695 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48696 {
48697 PyThreadState* __tstate = wxPyBeginAllowThreads();
48698 (arg1)->SetNonFlexibleGrowMode(arg2);
48699 wxPyEndAllowThreads(__tstate);
48700 if (PyErr_Occurred()) SWIG_fail;
48701 }
48702 resultobj = SWIG_Py_Void();
48703 return resultobj;
48704 fail:
48705 return NULL;
48706 }
48707
48708
48709 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48710 PyObject *resultobj = 0;
48711 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48712 wxFlexSizerGrowMode result;
48713 void *argp1 = 0 ;
48714 int res1 = 0 ;
48715 PyObject *swig_obj[1] ;
48716
48717 if (!args) SWIG_fail;
48718 swig_obj[0] = args;
48719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48720 if (!SWIG_IsOK(res1)) {
48721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48722 }
48723 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48724 {
48725 PyThreadState* __tstate = wxPyBeginAllowThreads();
48726 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48727 wxPyEndAllowThreads(__tstate);
48728 if (PyErr_Occurred()) SWIG_fail;
48729 }
48730 resultobj = SWIG_From_int(static_cast< int >(result));
48731 return resultobj;
48732 fail:
48733 return NULL;
48734 }
48735
48736
48737 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48738 PyObject *resultobj = 0;
48739 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48740 wxArrayInt *result = 0 ;
48741 void *argp1 = 0 ;
48742 int res1 = 0 ;
48743 PyObject *swig_obj[1] ;
48744
48745 if (!args) SWIG_fail;
48746 swig_obj[0] = args;
48747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48748 if (!SWIG_IsOK(res1)) {
48749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48750 }
48751 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48752 {
48753 PyThreadState* __tstate = wxPyBeginAllowThreads();
48754 {
48755 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48756 result = (wxArrayInt *) &_result_ref;
48757 }
48758 wxPyEndAllowThreads(__tstate);
48759 if (PyErr_Occurred()) SWIG_fail;
48760 }
48761 {
48762 resultobj = PyList_New(0);
48763 size_t idx;
48764 for (idx = 0; idx < result->GetCount(); idx += 1) {
48765 PyObject* val = PyInt_FromLong( result->Item(idx) );
48766 PyList_Append(resultobj, val);
48767 Py_DECREF(val);
48768 }
48769 }
48770 return resultobj;
48771 fail:
48772 return NULL;
48773 }
48774
48775
48776 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48777 PyObject *resultobj = 0;
48778 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48779 wxArrayInt *result = 0 ;
48780 void *argp1 = 0 ;
48781 int res1 = 0 ;
48782 PyObject *swig_obj[1] ;
48783
48784 if (!args) SWIG_fail;
48785 swig_obj[0] = args;
48786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48787 if (!SWIG_IsOK(res1)) {
48788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48789 }
48790 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48791 {
48792 PyThreadState* __tstate = wxPyBeginAllowThreads();
48793 {
48794 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48795 result = (wxArrayInt *) &_result_ref;
48796 }
48797 wxPyEndAllowThreads(__tstate);
48798 if (PyErr_Occurred()) SWIG_fail;
48799 }
48800 {
48801 resultobj = PyList_New(0);
48802 size_t idx;
48803 for (idx = 0; idx < result->GetCount(); idx += 1) {
48804 PyObject* val = PyInt_FromLong( result->Item(idx) );
48805 PyList_Append(resultobj, val);
48806 Py_DECREF(val);
48807 }
48808 }
48809 return resultobj;
48810 fail:
48811 return NULL;
48812 }
48813
48814
48815 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48816 PyObject *obj;
48817 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48818 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48819 return SWIG_Py_Void();
48820 }
48821
48822 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48823 return SWIG_Python_InitShadowInstance(args);
48824 }
48825
48826 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48827 PyObject *resultobj = 0;
48828 wxStdDialogButtonSizer *result = 0 ;
48829
48830 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48831 {
48832 PyThreadState* __tstate = wxPyBeginAllowThreads();
48833 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48834 wxPyEndAllowThreads(__tstate);
48835 if (PyErr_Occurred()) SWIG_fail;
48836 }
48837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48838 return resultobj;
48839 fail:
48840 return NULL;
48841 }
48842
48843
48844 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48845 PyObject *resultobj = 0;
48846 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48847 wxButton *arg2 = (wxButton *) 0 ;
48848 void *argp1 = 0 ;
48849 int res1 = 0 ;
48850 void *argp2 = 0 ;
48851 int res2 = 0 ;
48852 PyObject * obj0 = 0 ;
48853 PyObject * obj1 = 0 ;
48854 char * kwnames[] = {
48855 (char *) "self",(char *) "button", NULL
48856 };
48857
48858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48860 if (!SWIG_IsOK(res1)) {
48861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48862 }
48863 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48865 if (!SWIG_IsOK(res2)) {
48866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48867 }
48868 arg2 = reinterpret_cast< wxButton * >(argp2);
48869 {
48870 PyThreadState* __tstate = wxPyBeginAllowThreads();
48871 (arg1)->AddButton(arg2);
48872 wxPyEndAllowThreads(__tstate);
48873 if (PyErr_Occurred()) SWIG_fail;
48874 }
48875 resultobj = SWIG_Py_Void();
48876 return resultobj;
48877 fail:
48878 return NULL;
48879 }
48880
48881
48882 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48883 PyObject *resultobj = 0;
48884 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48885 void *argp1 = 0 ;
48886 int res1 = 0 ;
48887 PyObject *swig_obj[1] ;
48888
48889 if (!args) SWIG_fail;
48890 swig_obj[0] = args;
48891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48892 if (!SWIG_IsOK(res1)) {
48893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48894 }
48895 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48896 {
48897 PyThreadState* __tstate = wxPyBeginAllowThreads();
48898 (arg1)->Realize();
48899 wxPyEndAllowThreads(__tstate);
48900 if (PyErr_Occurred()) SWIG_fail;
48901 }
48902 resultobj = SWIG_Py_Void();
48903 return resultobj;
48904 fail:
48905 return NULL;
48906 }
48907
48908
48909 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48910 PyObject *resultobj = 0;
48911 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48912 wxButton *arg2 = (wxButton *) 0 ;
48913 void *argp1 = 0 ;
48914 int res1 = 0 ;
48915 void *argp2 = 0 ;
48916 int res2 = 0 ;
48917 PyObject * obj0 = 0 ;
48918 PyObject * obj1 = 0 ;
48919 char * kwnames[] = {
48920 (char *) "self",(char *) "button", NULL
48921 };
48922
48923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48925 if (!SWIG_IsOK(res1)) {
48926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48927 }
48928 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48929 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48930 if (!SWIG_IsOK(res2)) {
48931 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48932 }
48933 arg2 = reinterpret_cast< wxButton * >(argp2);
48934 {
48935 PyThreadState* __tstate = wxPyBeginAllowThreads();
48936 (arg1)->SetAffirmativeButton(arg2);
48937 wxPyEndAllowThreads(__tstate);
48938 if (PyErr_Occurred()) SWIG_fail;
48939 }
48940 resultobj = SWIG_Py_Void();
48941 return resultobj;
48942 fail:
48943 return NULL;
48944 }
48945
48946
48947 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48948 PyObject *resultobj = 0;
48949 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48950 wxButton *arg2 = (wxButton *) 0 ;
48951 void *argp1 = 0 ;
48952 int res1 = 0 ;
48953 void *argp2 = 0 ;
48954 int res2 = 0 ;
48955 PyObject * obj0 = 0 ;
48956 PyObject * obj1 = 0 ;
48957 char * kwnames[] = {
48958 (char *) "self",(char *) "button", NULL
48959 };
48960
48961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48963 if (!SWIG_IsOK(res1)) {
48964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48965 }
48966 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48968 if (!SWIG_IsOK(res2)) {
48969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48970 }
48971 arg2 = reinterpret_cast< wxButton * >(argp2);
48972 {
48973 PyThreadState* __tstate = wxPyBeginAllowThreads();
48974 (arg1)->SetNegativeButton(arg2);
48975 wxPyEndAllowThreads(__tstate);
48976 if (PyErr_Occurred()) SWIG_fail;
48977 }
48978 resultobj = SWIG_Py_Void();
48979 return resultobj;
48980 fail:
48981 return NULL;
48982 }
48983
48984
48985 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48986 PyObject *resultobj = 0;
48987 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48988 wxButton *arg2 = (wxButton *) 0 ;
48989 void *argp1 = 0 ;
48990 int res1 = 0 ;
48991 void *argp2 = 0 ;
48992 int res2 = 0 ;
48993 PyObject * obj0 = 0 ;
48994 PyObject * obj1 = 0 ;
48995 char * kwnames[] = {
48996 (char *) "self",(char *) "button", NULL
48997 };
48998
48999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49001 if (!SWIG_IsOK(res1)) {
49002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49003 }
49004 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49006 if (!SWIG_IsOK(res2)) {
49007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49008 }
49009 arg2 = reinterpret_cast< wxButton * >(argp2);
49010 {
49011 PyThreadState* __tstate = wxPyBeginAllowThreads();
49012 (arg1)->SetCancelButton(arg2);
49013 wxPyEndAllowThreads(__tstate);
49014 if (PyErr_Occurred()) SWIG_fail;
49015 }
49016 resultobj = SWIG_Py_Void();
49017 return resultobj;
49018 fail:
49019 return NULL;
49020 }
49021
49022
49023 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49024 PyObject *resultobj = 0;
49025 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49026 wxButton *result = 0 ;
49027 void *argp1 = 0 ;
49028 int res1 = 0 ;
49029 PyObject *swig_obj[1] ;
49030
49031 if (!args) SWIG_fail;
49032 swig_obj[0] = args;
49033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49034 if (!SWIG_IsOK(res1)) {
49035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49036 }
49037 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49038 {
49039 PyThreadState* __tstate = wxPyBeginAllowThreads();
49040 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49041 wxPyEndAllowThreads(__tstate);
49042 if (PyErr_Occurred()) SWIG_fail;
49043 }
49044 {
49045 resultobj = wxPyMake_wxObject(result, (bool)0);
49046 }
49047 return resultobj;
49048 fail:
49049 return NULL;
49050 }
49051
49052
49053 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49054 PyObject *resultobj = 0;
49055 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49056 wxButton *result = 0 ;
49057 void *argp1 = 0 ;
49058 int res1 = 0 ;
49059 PyObject *swig_obj[1] ;
49060
49061 if (!args) SWIG_fail;
49062 swig_obj[0] = args;
49063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49064 if (!SWIG_IsOK(res1)) {
49065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49066 }
49067 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49068 {
49069 PyThreadState* __tstate = wxPyBeginAllowThreads();
49070 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49071 wxPyEndAllowThreads(__tstate);
49072 if (PyErr_Occurred()) SWIG_fail;
49073 }
49074 {
49075 resultobj = wxPyMake_wxObject(result, (bool)0);
49076 }
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49084 PyObject *resultobj = 0;
49085 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49086 wxButton *result = 0 ;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 PyObject *swig_obj[1] ;
49090
49091 if (!args) SWIG_fail;
49092 swig_obj[0] = args;
49093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49096 }
49097 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49098 {
49099 PyThreadState* __tstate = wxPyBeginAllowThreads();
49100 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49101 wxPyEndAllowThreads(__tstate);
49102 if (PyErr_Occurred()) SWIG_fail;
49103 }
49104 {
49105 resultobj = wxPyMake_wxObject(result, (bool)0);
49106 }
49107 return resultobj;
49108 fail:
49109 return NULL;
49110 }
49111
49112
49113 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49114 PyObject *resultobj = 0;
49115 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49116 wxButton *result = 0 ;
49117 void *argp1 = 0 ;
49118 int res1 = 0 ;
49119 PyObject *swig_obj[1] ;
49120
49121 if (!args) SWIG_fail;
49122 swig_obj[0] = args;
49123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49124 if (!SWIG_IsOK(res1)) {
49125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49126 }
49127 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49128 {
49129 PyThreadState* __tstate = wxPyBeginAllowThreads();
49130 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49131 wxPyEndAllowThreads(__tstate);
49132 if (PyErr_Occurred()) SWIG_fail;
49133 }
49134 {
49135 resultobj = wxPyMake_wxObject(result, (bool)0);
49136 }
49137 return resultobj;
49138 fail:
49139 return NULL;
49140 }
49141
49142
49143 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49144 PyObject *resultobj = 0;
49145 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49146 wxButton *result = 0 ;
49147 void *argp1 = 0 ;
49148 int res1 = 0 ;
49149 PyObject *swig_obj[1] ;
49150
49151 if (!args) SWIG_fail;
49152 swig_obj[0] = args;
49153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49154 if (!SWIG_IsOK(res1)) {
49155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49156 }
49157 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49158 {
49159 PyThreadState* __tstate = wxPyBeginAllowThreads();
49160 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49161 wxPyEndAllowThreads(__tstate);
49162 if (PyErr_Occurred()) SWIG_fail;
49163 }
49164 {
49165 resultobj = wxPyMake_wxObject(result, (bool)0);
49166 }
49167 return resultobj;
49168 fail:
49169 return NULL;
49170 }
49171
49172
49173 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49174 PyObject *obj;
49175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49176 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49177 return SWIG_Py_Void();
49178 }
49179
49180 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49181 return SWIG_Python_InitShadowInstance(args);
49182 }
49183
49184 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49185 PyObject *resultobj = 0;
49186 int arg1 = (int) 0 ;
49187 int arg2 = (int) 0 ;
49188 wxGBPosition *result = 0 ;
49189 int val1 ;
49190 int ecode1 = 0 ;
49191 int val2 ;
49192 int ecode2 = 0 ;
49193 PyObject * obj0 = 0 ;
49194 PyObject * obj1 = 0 ;
49195 char * kwnames[] = {
49196 (char *) "row",(char *) "col", NULL
49197 };
49198
49199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49200 if (obj0) {
49201 ecode1 = SWIG_AsVal_int(obj0, &val1);
49202 if (!SWIG_IsOK(ecode1)) {
49203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49204 }
49205 arg1 = static_cast< int >(val1);
49206 }
49207 if (obj1) {
49208 ecode2 = SWIG_AsVal_int(obj1, &val2);
49209 if (!SWIG_IsOK(ecode2)) {
49210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49211 }
49212 arg2 = static_cast< int >(val2);
49213 }
49214 {
49215 PyThreadState* __tstate = wxPyBeginAllowThreads();
49216 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49217 wxPyEndAllowThreads(__tstate);
49218 if (PyErr_Occurred()) SWIG_fail;
49219 }
49220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49221 return resultobj;
49222 fail:
49223 return NULL;
49224 }
49225
49226
49227 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49228 PyObject *resultobj = 0;
49229 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49230 void *argp1 = 0 ;
49231 int res1 = 0 ;
49232 PyObject *swig_obj[1] ;
49233
49234 if (!args) SWIG_fail;
49235 swig_obj[0] = args;
49236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49237 if (!SWIG_IsOK(res1)) {
49238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49239 }
49240 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49241 {
49242 PyThreadState* __tstate = wxPyBeginAllowThreads();
49243 delete arg1;
49244
49245 wxPyEndAllowThreads(__tstate);
49246 if (PyErr_Occurred()) SWIG_fail;
49247 }
49248 resultobj = SWIG_Py_Void();
49249 return resultobj;
49250 fail:
49251 return NULL;
49252 }
49253
49254
49255 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49256 PyObject *resultobj = 0;
49257 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49258 int result;
49259 void *argp1 = 0 ;
49260 int res1 = 0 ;
49261 PyObject *swig_obj[1] ;
49262
49263 if (!args) SWIG_fail;
49264 swig_obj[0] = args;
49265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49266 if (!SWIG_IsOK(res1)) {
49267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49268 }
49269 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49270 {
49271 PyThreadState* __tstate = wxPyBeginAllowThreads();
49272 result = (int)((wxGBPosition const *)arg1)->GetRow();
49273 wxPyEndAllowThreads(__tstate);
49274 if (PyErr_Occurred()) SWIG_fail;
49275 }
49276 resultobj = SWIG_From_int(static_cast< int >(result));
49277 return resultobj;
49278 fail:
49279 return NULL;
49280 }
49281
49282
49283 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49284 PyObject *resultobj = 0;
49285 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49286 int result;
49287 void *argp1 = 0 ;
49288 int res1 = 0 ;
49289 PyObject *swig_obj[1] ;
49290
49291 if (!args) SWIG_fail;
49292 swig_obj[0] = args;
49293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49294 if (!SWIG_IsOK(res1)) {
49295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49296 }
49297 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49298 {
49299 PyThreadState* __tstate = wxPyBeginAllowThreads();
49300 result = (int)((wxGBPosition const *)arg1)->GetCol();
49301 wxPyEndAllowThreads(__tstate);
49302 if (PyErr_Occurred()) SWIG_fail;
49303 }
49304 resultobj = SWIG_From_int(static_cast< int >(result));
49305 return resultobj;
49306 fail:
49307 return NULL;
49308 }
49309
49310
49311 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49312 PyObject *resultobj = 0;
49313 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49314 int arg2 ;
49315 void *argp1 = 0 ;
49316 int res1 = 0 ;
49317 int val2 ;
49318 int ecode2 = 0 ;
49319 PyObject * obj0 = 0 ;
49320 PyObject * obj1 = 0 ;
49321 char * kwnames[] = {
49322 (char *) "self",(char *) "row", NULL
49323 };
49324
49325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49327 if (!SWIG_IsOK(res1)) {
49328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49329 }
49330 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49331 ecode2 = SWIG_AsVal_int(obj1, &val2);
49332 if (!SWIG_IsOK(ecode2)) {
49333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49334 }
49335 arg2 = static_cast< int >(val2);
49336 {
49337 PyThreadState* __tstate = wxPyBeginAllowThreads();
49338 (arg1)->SetRow(arg2);
49339 wxPyEndAllowThreads(__tstate);
49340 if (PyErr_Occurred()) SWIG_fail;
49341 }
49342 resultobj = SWIG_Py_Void();
49343 return resultobj;
49344 fail:
49345 return NULL;
49346 }
49347
49348
49349 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49350 PyObject *resultobj = 0;
49351 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49352 int arg2 ;
49353 void *argp1 = 0 ;
49354 int res1 = 0 ;
49355 int val2 ;
49356 int ecode2 = 0 ;
49357 PyObject * obj0 = 0 ;
49358 PyObject * obj1 = 0 ;
49359 char * kwnames[] = {
49360 (char *) "self",(char *) "col", NULL
49361 };
49362
49363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49365 if (!SWIG_IsOK(res1)) {
49366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49367 }
49368 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49369 ecode2 = SWIG_AsVal_int(obj1, &val2);
49370 if (!SWIG_IsOK(ecode2)) {
49371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49372 }
49373 arg2 = static_cast< int >(val2);
49374 {
49375 PyThreadState* __tstate = wxPyBeginAllowThreads();
49376 (arg1)->SetCol(arg2);
49377 wxPyEndAllowThreads(__tstate);
49378 if (PyErr_Occurred()) SWIG_fail;
49379 }
49380 resultobj = SWIG_Py_Void();
49381 return resultobj;
49382 fail:
49383 return NULL;
49384 }
49385
49386
49387 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49388 PyObject *resultobj = 0;
49389 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49390 PyObject *arg2 = (PyObject *) 0 ;
49391 bool result;
49392 void *argp1 = 0 ;
49393 int res1 = 0 ;
49394 PyObject * obj0 = 0 ;
49395 PyObject * obj1 = 0 ;
49396 char * kwnames[] = {
49397 (char *) "self",(char *) "other", NULL
49398 };
49399
49400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49402 if (!SWIG_IsOK(res1)) {
49403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49404 }
49405 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49406 arg2 = obj1;
49407 {
49408 result = (bool)wxGBPosition___eq__(arg1,arg2);
49409 if (PyErr_Occurred()) SWIG_fail;
49410 }
49411 {
49412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49413 }
49414 return resultobj;
49415 fail:
49416 return NULL;
49417 }
49418
49419
49420 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49421 PyObject *resultobj = 0;
49422 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49423 PyObject *arg2 = (PyObject *) 0 ;
49424 bool result;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 PyObject * obj0 = 0 ;
49428 PyObject * obj1 = 0 ;
49429 char * kwnames[] = {
49430 (char *) "self",(char *) "other", NULL
49431 };
49432
49433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49435 if (!SWIG_IsOK(res1)) {
49436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49437 }
49438 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49439 arg2 = obj1;
49440 {
49441 result = (bool)wxGBPosition___ne__(arg1,arg2);
49442 if (PyErr_Occurred()) SWIG_fail;
49443 }
49444 {
49445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49446 }
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49456 int arg2 = (int) 0 ;
49457 int arg3 = (int) 0 ;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 int val2 ;
49461 int ecode2 = 0 ;
49462 int val3 ;
49463 int ecode3 = 0 ;
49464 PyObject * obj0 = 0 ;
49465 PyObject * obj1 = 0 ;
49466 PyObject * obj2 = 0 ;
49467 char * kwnames[] = {
49468 (char *) "self",(char *) "row",(char *) "col", NULL
49469 };
49470
49471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49473 if (!SWIG_IsOK(res1)) {
49474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49475 }
49476 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49477 if (obj1) {
49478 ecode2 = SWIG_AsVal_int(obj1, &val2);
49479 if (!SWIG_IsOK(ecode2)) {
49480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49481 }
49482 arg2 = static_cast< int >(val2);
49483 }
49484 if (obj2) {
49485 ecode3 = SWIG_AsVal_int(obj2, &val3);
49486 if (!SWIG_IsOK(ecode3)) {
49487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49488 }
49489 arg3 = static_cast< int >(val3);
49490 }
49491 {
49492 PyThreadState* __tstate = wxPyBeginAllowThreads();
49493 wxGBPosition_Set(arg1,arg2,arg3);
49494 wxPyEndAllowThreads(__tstate);
49495 if (PyErr_Occurred()) SWIG_fail;
49496 }
49497 resultobj = SWIG_Py_Void();
49498 return resultobj;
49499 fail:
49500 return NULL;
49501 }
49502
49503
49504 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49505 PyObject *resultobj = 0;
49506 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49507 PyObject *result = 0 ;
49508 void *argp1 = 0 ;
49509 int res1 = 0 ;
49510 PyObject *swig_obj[1] ;
49511
49512 if (!args) SWIG_fail;
49513 swig_obj[0] = args;
49514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49515 if (!SWIG_IsOK(res1)) {
49516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49517 }
49518 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49519 {
49520 PyThreadState* __tstate = wxPyBeginAllowThreads();
49521 result = (PyObject *)wxGBPosition_Get(arg1);
49522 wxPyEndAllowThreads(__tstate);
49523 if (PyErr_Occurred()) SWIG_fail;
49524 }
49525 resultobj = result;
49526 return resultobj;
49527 fail:
49528 return NULL;
49529 }
49530
49531
49532 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49533 PyObject *obj;
49534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49535 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49536 return SWIG_Py_Void();
49537 }
49538
49539 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49540 return SWIG_Python_InitShadowInstance(args);
49541 }
49542
49543 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49544 PyObject *resultobj = 0;
49545 int arg1 = (int) 1 ;
49546 int arg2 = (int) 1 ;
49547 wxGBSpan *result = 0 ;
49548 int val1 ;
49549 int ecode1 = 0 ;
49550 int val2 ;
49551 int ecode2 = 0 ;
49552 PyObject * obj0 = 0 ;
49553 PyObject * obj1 = 0 ;
49554 char * kwnames[] = {
49555 (char *) "rowspan",(char *) "colspan", NULL
49556 };
49557
49558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49559 if (obj0) {
49560 ecode1 = SWIG_AsVal_int(obj0, &val1);
49561 if (!SWIG_IsOK(ecode1)) {
49562 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49563 }
49564 arg1 = static_cast< int >(val1);
49565 }
49566 if (obj1) {
49567 ecode2 = SWIG_AsVal_int(obj1, &val2);
49568 if (!SWIG_IsOK(ecode2)) {
49569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49570 }
49571 arg2 = static_cast< int >(val2);
49572 }
49573 {
49574 PyThreadState* __tstate = wxPyBeginAllowThreads();
49575 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49576 wxPyEndAllowThreads(__tstate);
49577 if (PyErr_Occurred()) SWIG_fail;
49578 }
49579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49580 return resultobj;
49581 fail:
49582 return NULL;
49583 }
49584
49585
49586 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49587 PyObject *resultobj = 0;
49588 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49589 void *argp1 = 0 ;
49590 int res1 = 0 ;
49591 PyObject *swig_obj[1] ;
49592
49593 if (!args) SWIG_fail;
49594 swig_obj[0] = args;
49595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49596 if (!SWIG_IsOK(res1)) {
49597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49598 }
49599 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49600 {
49601 PyThreadState* __tstate = wxPyBeginAllowThreads();
49602 delete arg1;
49603
49604 wxPyEndAllowThreads(__tstate);
49605 if (PyErr_Occurred()) SWIG_fail;
49606 }
49607 resultobj = SWIG_Py_Void();
49608 return resultobj;
49609 fail:
49610 return NULL;
49611 }
49612
49613
49614 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49615 PyObject *resultobj = 0;
49616 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49617 int result;
49618 void *argp1 = 0 ;
49619 int res1 = 0 ;
49620 PyObject *swig_obj[1] ;
49621
49622 if (!args) SWIG_fail;
49623 swig_obj[0] = args;
49624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49625 if (!SWIG_IsOK(res1)) {
49626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49627 }
49628 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49629 {
49630 PyThreadState* __tstate = wxPyBeginAllowThreads();
49631 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49632 wxPyEndAllowThreads(__tstate);
49633 if (PyErr_Occurred()) SWIG_fail;
49634 }
49635 resultobj = SWIG_From_int(static_cast< int >(result));
49636 return resultobj;
49637 fail:
49638 return NULL;
49639 }
49640
49641
49642 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49643 PyObject *resultobj = 0;
49644 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49645 int result;
49646 void *argp1 = 0 ;
49647 int res1 = 0 ;
49648 PyObject *swig_obj[1] ;
49649
49650 if (!args) SWIG_fail;
49651 swig_obj[0] = args;
49652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49653 if (!SWIG_IsOK(res1)) {
49654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49655 }
49656 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49657 {
49658 PyThreadState* __tstate = wxPyBeginAllowThreads();
49659 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49660 wxPyEndAllowThreads(__tstate);
49661 if (PyErr_Occurred()) SWIG_fail;
49662 }
49663 resultobj = SWIG_From_int(static_cast< int >(result));
49664 return resultobj;
49665 fail:
49666 return NULL;
49667 }
49668
49669
49670 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49671 PyObject *resultobj = 0;
49672 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49673 int arg2 ;
49674 void *argp1 = 0 ;
49675 int res1 = 0 ;
49676 int val2 ;
49677 int ecode2 = 0 ;
49678 PyObject * obj0 = 0 ;
49679 PyObject * obj1 = 0 ;
49680 char * kwnames[] = {
49681 (char *) "self",(char *) "rowspan", NULL
49682 };
49683
49684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49686 if (!SWIG_IsOK(res1)) {
49687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49688 }
49689 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49690 ecode2 = SWIG_AsVal_int(obj1, &val2);
49691 if (!SWIG_IsOK(ecode2)) {
49692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49693 }
49694 arg2 = static_cast< int >(val2);
49695 {
49696 PyThreadState* __tstate = wxPyBeginAllowThreads();
49697 (arg1)->SetRowspan(arg2);
49698 wxPyEndAllowThreads(__tstate);
49699 if (PyErr_Occurred()) SWIG_fail;
49700 }
49701 resultobj = SWIG_Py_Void();
49702 return resultobj;
49703 fail:
49704 return NULL;
49705 }
49706
49707
49708 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49709 PyObject *resultobj = 0;
49710 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49711 int arg2 ;
49712 void *argp1 = 0 ;
49713 int res1 = 0 ;
49714 int val2 ;
49715 int ecode2 = 0 ;
49716 PyObject * obj0 = 0 ;
49717 PyObject * obj1 = 0 ;
49718 char * kwnames[] = {
49719 (char *) "self",(char *) "colspan", NULL
49720 };
49721
49722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49724 if (!SWIG_IsOK(res1)) {
49725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49726 }
49727 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49728 ecode2 = SWIG_AsVal_int(obj1, &val2);
49729 if (!SWIG_IsOK(ecode2)) {
49730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49731 }
49732 arg2 = static_cast< int >(val2);
49733 {
49734 PyThreadState* __tstate = wxPyBeginAllowThreads();
49735 (arg1)->SetColspan(arg2);
49736 wxPyEndAllowThreads(__tstate);
49737 if (PyErr_Occurred()) SWIG_fail;
49738 }
49739 resultobj = SWIG_Py_Void();
49740 return resultobj;
49741 fail:
49742 return NULL;
49743 }
49744
49745
49746 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49747 PyObject *resultobj = 0;
49748 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49749 PyObject *arg2 = (PyObject *) 0 ;
49750 bool result;
49751 void *argp1 = 0 ;
49752 int res1 = 0 ;
49753 PyObject * obj0 = 0 ;
49754 PyObject * obj1 = 0 ;
49755 char * kwnames[] = {
49756 (char *) "self",(char *) "other", NULL
49757 };
49758
49759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49761 if (!SWIG_IsOK(res1)) {
49762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49763 }
49764 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49765 arg2 = obj1;
49766 {
49767 result = (bool)wxGBSpan___eq__(arg1,arg2);
49768 if (PyErr_Occurred()) SWIG_fail;
49769 }
49770 {
49771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49772 }
49773 return resultobj;
49774 fail:
49775 return NULL;
49776 }
49777
49778
49779 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49780 PyObject *resultobj = 0;
49781 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49782 PyObject *arg2 = (PyObject *) 0 ;
49783 bool result;
49784 void *argp1 = 0 ;
49785 int res1 = 0 ;
49786 PyObject * obj0 = 0 ;
49787 PyObject * obj1 = 0 ;
49788 char * kwnames[] = {
49789 (char *) "self",(char *) "other", NULL
49790 };
49791
49792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49794 if (!SWIG_IsOK(res1)) {
49795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49796 }
49797 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49798 arg2 = obj1;
49799 {
49800 result = (bool)wxGBSpan___ne__(arg1,arg2);
49801 if (PyErr_Occurred()) SWIG_fail;
49802 }
49803 {
49804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49805 }
49806 return resultobj;
49807 fail:
49808 return NULL;
49809 }
49810
49811
49812 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49813 PyObject *resultobj = 0;
49814 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49815 int arg2 = (int) 1 ;
49816 int arg3 = (int) 1 ;
49817 void *argp1 = 0 ;
49818 int res1 = 0 ;
49819 int val2 ;
49820 int ecode2 = 0 ;
49821 int val3 ;
49822 int ecode3 = 0 ;
49823 PyObject * obj0 = 0 ;
49824 PyObject * obj1 = 0 ;
49825 PyObject * obj2 = 0 ;
49826 char * kwnames[] = {
49827 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49828 };
49829
49830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49832 if (!SWIG_IsOK(res1)) {
49833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49834 }
49835 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49836 if (obj1) {
49837 ecode2 = SWIG_AsVal_int(obj1, &val2);
49838 if (!SWIG_IsOK(ecode2)) {
49839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49840 }
49841 arg2 = static_cast< int >(val2);
49842 }
49843 if (obj2) {
49844 ecode3 = SWIG_AsVal_int(obj2, &val3);
49845 if (!SWIG_IsOK(ecode3)) {
49846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49847 }
49848 arg3 = static_cast< int >(val3);
49849 }
49850 {
49851 PyThreadState* __tstate = wxPyBeginAllowThreads();
49852 wxGBSpan_Set(arg1,arg2,arg3);
49853 wxPyEndAllowThreads(__tstate);
49854 if (PyErr_Occurred()) SWIG_fail;
49855 }
49856 resultobj = SWIG_Py_Void();
49857 return resultobj;
49858 fail:
49859 return NULL;
49860 }
49861
49862
49863 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49864 PyObject *resultobj = 0;
49865 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49866 PyObject *result = 0 ;
49867 void *argp1 = 0 ;
49868 int res1 = 0 ;
49869 PyObject *swig_obj[1] ;
49870
49871 if (!args) SWIG_fail;
49872 swig_obj[0] = args;
49873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49874 if (!SWIG_IsOK(res1)) {
49875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49876 }
49877 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49878 {
49879 PyThreadState* __tstate = wxPyBeginAllowThreads();
49880 result = (PyObject *)wxGBSpan_Get(arg1);
49881 wxPyEndAllowThreads(__tstate);
49882 if (PyErr_Occurred()) SWIG_fail;
49883 }
49884 resultobj = result;
49885 return resultobj;
49886 fail:
49887 return NULL;
49888 }
49889
49890
49891 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49892 PyObject *obj;
49893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49894 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49895 return SWIG_Py_Void();
49896 }
49897
49898 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49899 return SWIG_Python_InitShadowInstance(args);
49900 }
49901
49902 SWIGINTERN int DefaultSpan_set(PyObject *) {
49903 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49904 return 1;
49905 }
49906
49907
49908 SWIGINTERN PyObject *DefaultSpan_get(void) {
49909 PyObject *pyobj = 0;
49910
49911 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49912 return pyobj;
49913 }
49914
49915
49916 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49917 PyObject *resultobj = 0;
49918 wxGBSizerItem *result = 0 ;
49919
49920 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49921 {
49922 PyThreadState* __tstate = wxPyBeginAllowThreads();
49923 result = (wxGBSizerItem *)new wxGBSizerItem();
49924 wxPyEndAllowThreads(__tstate);
49925 if (PyErr_Occurred()) SWIG_fail;
49926 }
49927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49928 return resultobj;
49929 fail:
49930 return NULL;
49931 }
49932
49933
49934 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49935 PyObject *resultobj = 0;
49936 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49937 void *argp1 = 0 ;
49938 int res1 = 0 ;
49939 PyObject *swig_obj[1] ;
49940
49941 if (!args) SWIG_fail;
49942 swig_obj[0] = args;
49943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49944 if (!SWIG_IsOK(res1)) {
49945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49946 }
49947 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49948 {
49949 PyThreadState* __tstate = wxPyBeginAllowThreads();
49950 delete arg1;
49951
49952 wxPyEndAllowThreads(__tstate);
49953 if (PyErr_Occurred()) SWIG_fail;
49954 }
49955 resultobj = SWIG_Py_Void();
49956 return resultobj;
49957 fail:
49958 return NULL;
49959 }
49960
49961
49962 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49963 PyObject *resultobj = 0;
49964 wxWindow *arg1 = (wxWindow *) 0 ;
49965 wxGBPosition *arg2 = 0 ;
49966 wxGBSpan *arg3 = 0 ;
49967 int arg4 ;
49968 int arg5 ;
49969 PyObject *arg6 = (PyObject *) NULL ;
49970 wxGBSizerItem *result = 0 ;
49971 void *argp1 = 0 ;
49972 int res1 = 0 ;
49973 wxGBPosition temp2 ;
49974 wxGBSpan temp3 ;
49975 int val4 ;
49976 int ecode4 = 0 ;
49977 int val5 ;
49978 int ecode5 = 0 ;
49979 PyObject * obj0 = 0 ;
49980 PyObject * obj1 = 0 ;
49981 PyObject * obj2 = 0 ;
49982 PyObject * obj3 = 0 ;
49983 PyObject * obj4 = 0 ;
49984 PyObject * obj5 = 0 ;
49985 char * kwnames[] = {
49986 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49987 };
49988
49989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49991 if (!SWIG_IsOK(res1)) {
49992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49993 }
49994 arg1 = reinterpret_cast< wxWindow * >(argp1);
49995 {
49996 arg2 = &temp2;
49997 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49998 }
49999 {
50000 arg3 = &temp3;
50001 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50002 }
50003 ecode4 = SWIG_AsVal_int(obj3, &val4);
50004 if (!SWIG_IsOK(ecode4)) {
50005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50006 }
50007 arg4 = static_cast< int >(val4);
50008 ecode5 = SWIG_AsVal_int(obj4, &val5);
50009 if (!SWIG_IsOK(ecode5)) {
50010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50011 }
50012 arg5 = static_cast< int >(val5);
50013 if (obj5) {
50014 arg6 = obj5;
50015 }
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50030 PyObject *resultobj = 0;
50031 wxSizer *arg1 = (wxSizer *) 0 ;
50032 wxGBPosition *arg2 = 0 ;
50033 wxGBSpan *arg3 = 0 ;
50034 int arg4 ;
50035 int arg5 ;
50036 PyObject *arg6 = (PyObject *) NULL ;
50037 wxGBSizerItem *result = 0 ;
50038 int res1 = 0 ;
50039 wxGBPosition temp2 ;
50040 wxGBSpan temp3 ;
50041 int val4 ;
50042 int ecode4 = 0 ;
50043 int val5 ;
50044 int ecode5 = 0 ;
50045 PyObject * obj0 = 0 ;
50046 PyObject * obj1 = 0 ;
50047 PyObject * obj2 = 0 ;
50048 PyObject * obj3 = 0 ;
50049 PyObject * obj4 = 0 ;
50050 PyObject * obj5 = 0 ;
50051 char * kwnames[] = {
50052 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50053 };
50054
50055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50056 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50057 if (!SWIG_IsOK(res1)) {
50058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50059 }
50060 {
50061 arg2 = &temp2;
50062 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50063 }
50064 {
50065 arg3 = &temp3;
50066 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50067 }
50068 ecode4 = SWIG_AsVal_int(obj3, &val4);
50069 if (!SWIG_IsOK(ecode4)) {
50070 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50071 }
50072 arg4 = static_cast< int >(val4);
50073 ecode5 = SWIG_AsVal_int(obj4, &val5);
50074 if (!SWIG_IsOK(ecode5)) {
50075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50076 }
50077 arg5 = static_cast< int >(val5);
50078 if (obj5) {
50079 arg6 = obj5;
50080 }
50081 {
50082 PyThreadState* __tstate = wxPyBeginAllowThreads();
50083 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50084 wxPyEndAllowThreads(__tstate);
50085 if (PyErr_Occurred()) SWIG_fail;
50086 }
50087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50088 return resultobj;
50089 fail:
50090 return NULL;
50091 }
50092
50093
50094 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50095 PyObject *resultobj = 0;
50096 int arg1 ;
50097 int arg2 ;
50098 wxGBPosition *arg3 = 0 ;
50099 wxGBSpan *arg4 = 0 ;
50100 int arg5 ;
50101 int arg6 ;
50102 PyObject *arg7 = (PyObject *) NULL ;
50103 wxGBSizerItem *result = 0 ;
50104 int val1 ;
50105 int ecode1 = 0 ;
50106 int val2 ;
50107 int ecode2 = 0 ;
50108 wxGBPosition temp3 ;
50109 wxGBSpan temp4 ;
50110 int val5 ;
50111 int ecode5 = 0 ;
50112 int val6 ;
50113 int ecode6 = 0 ;
50114 PyObject * obj0 = 0 ;
50115 PyObject * obj1 = 0 ;
50116 PyObject * obj2 = 0 ;
50117 PyObject * obj3 = 0 ;
50118 PyObject * obj4 = 0 ;
50119 PyObject * obj5 = 0 ;
50120 PyObject * obj6 = 0 ;
50121 char * kwnames[] = {
50122 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50123 };
50124
50125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50126 ecode1 = SWIG_AsVal_int(obj0, &val1);
50127 if (!SWIG_IsOK(ecode1)) {
50128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50129 }
50130 arg1 = static_cast< int >(val1);
50131 ecode2 = SWIG_AsVal_int(obj1, &val2);
50132 if (!SWIG_IsOK(ecode2)) {
50133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50134 }
50135 arg2 = static_cast< int >(val2);
50136 {
50137 arg3 = &temp3;
50138 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50139 }
50140 {
50141 arg4 = &temp4;
50142 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50143 }
50144 ecode5 = SWIG_AsVal_int(obj4, &val5);
50145 if (!SWIG_IsOK(ecode5)) {
50146 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50147 }
50148 arg5 = static_cast< int >(val5);
50149 ecode6 = SWIG_AsVal_int(obj5, &val6);
50150 if (!SWIG_IsOK(ecode6)) {
50151 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50152 }
50153 arg6 = static_cast< int >(val6);
50154 if (obj6) {
50155 arg7 = obj6;
50156 }
50157 {
50158 PyThreadState* __tstate = wxPyBeginAllowThreads();
50159 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50160 wxPyEndAllowThreads(__tstate);
50161 if (PyErr_Occurred()) SWIG_fail;
50162 }
50163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50164 return resultobj;
50165 fail:
50166 return NULL;
50167 }
50168
50169
50170 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50171 PyObject *resultobj = 0;
50172 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50173 wxGBPosition result;
50174 void *argp1 = 0 ;
50175 int res1 = 0 ;
50176 PyObject *swig_obj[1] ;
50177
50178 if (!args) SWIG_fail;
50179 swig_obj[0] = args;
50180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50181 if (!SWIG_IsOK(res1)) {
50182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50183 }
50184 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50185 {
50186 PyThreadState* __tstate = wxPyBeginAllowThreads();
50187 result = ((wxGBSizerItem const *)arg1)->GetPos();
50188 wxPyEndAllowThreads(__tstate);
50189 if (PyErr_Occurred()) SWIG_fail;
50190 }
50191 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50192 return resultobj;
50193 fail:
50194 return NULL;
50195 }
50196
50197
50198 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50199 PyObject *resultobj = 0;
50200 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50201 wxGBSpan result;
50202 void *argp1 = 0 ;
50203 int res1 = 0 ;
50204 PyObject *swig_obj[1] ;
50205
50206 if (!args) SWIG_fail;
50207 swig_obj[0] = args;
50208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50209 if (!SWIG_IsOK(res1)) {
50210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50211 }
50212 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50213 {
50214 PyThreadState* __tstate = wxPyBeginAllowThreads();
50215 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50216 wxPyEndAllowThreads(__tstate);
50217 if (PyErr_Occurred()) SWIG_fail;
50218 }
50219 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50220 return resultobj;
50221 fail:
50222 return NULL;
50223 }
50224
50225
50226 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50227 PyObject *resultobj = 0;
50228 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50229 wxGBPosition *arg2 = 0 ;
50230 bool result;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 wxGBPosition temp2 ;
50234 PyObject * obj0 = 0 ;
50235 PyObject * obj1 = 0 ;
50236 char * kwnames[] = {
50237 (char *) "self",(char *) "pos", NULL
50238 };
50239
50240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50242 if (!SWIG_IsOK(res1)) {
50243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50244 }
50245 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50246 {
50247 arg2 = &temp2;
50248 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50249 }
50250 {
50251 PyThreadState* __tstate = wxPyBeginAllowThreads();
50252 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50253 wxPyEndAllowThreads(__tstate);
50254 if (PyErr_Occurred()) SWIG_fail;
50255 }
50256 {
50257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50258 }
50259 return resultobj;
50260 fail:
50261 return NULL;
50262 }
50263
50264
50265 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50266 PyObject *resultobj = 0;
50267 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50268 wxGBSpan *arg2 = 0 ;
50269 bool result;
50270 void *argp1 = 0 ;
50271 int res1 = 0 ;
50272 wxGBSpan temp2 ;
50273 PyObject * obj0 = 0 ;
50274 PyObject * obj1 = 0 ;
50275 char * kwnames[] = {
50276 (char *) "self",(char *) "span", NULL
50277 };
50278
50279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50281 if (!SWIG_IsOK(res1)) {
50282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50283 }
50284 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50285 {
50286 arg2 = &temp2;
50287 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50288 }
50289 {
50290 PyThreadState* __tstate = wxPyBeginAllowThreads();
50291 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50292 wxPyEndAllowThreads(__tstate);
50293 if (PyErr_Occurred()) SWIG_fail;
50294 }
50295 {
50296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50297 }
50298 return resultobj;
50299 fail:
50300 return NULL;
50301 }
50302
50303
50304 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50305 PyObject *resultobj = 0;
50306 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50307 wxGBSizerItem *arg2 = 0 ;
50308 bool result;
50309 void *argp1 = 0 ;
50310 int res1 = 0 ;
50311 void *argp2 = 0 ;
50312 int res2 = 0 ;
50313 PyObject * obj0 = 0 ;
50314 PyObject * obj1 = 0 ;
50315 char * kwnames[] = {
50316 (char *) "self",(char *) "other", NULL
50317 };
50318
50319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50321 if (!SWIG_IsOK(res1)) {
50322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50323 }
50324 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50326 if (!SWIG_IsOK(res2)) {
50327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50328 }
50329 if (!argp2) {
50330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50331 }
50332 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50333 {
50334 PyThreadState* __tstate = wxPyBeginAllowThreads();
50335 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50336 wxPyEndAllowThreads(__tstate);
50337 if (PyErr_Occurred()) SWIG_fail;
50338 }
50339 {
50340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50341 }
50342 return resultobj;
50343 fail:
50344 return NULL;
50345 }
50346
50347
50348 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50349 PyObject *resultobj = 0;
50350 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50351 wxGBPosition *arg2 = 0 ;
50352 wxGBSpan *arg3 = 0 ;
50353 bool result;
50354 void *argp1 = 0 ;
50355 int res1 = 0 ;
50356 wxGBPosition temp2 ;
50357 wxGBSpan temp3 ;
50358 PyObject * obj0 = 0 ;
50359 PyObject * obj1 = 0 ;
50360 PyObject * obj2 = 0 ;
50361 char * kwnames[] = {
50362 (char *) "self",(char *) "pos",(char *) "span", NULL
50363 };
50364
50365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50367 if (!SWIG_IsOK(res1)) {
50368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50369 }
50370 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50371 {
50372 arg2 = &temp2;
50373 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50374 }
50375 {
50376 arg3 = &temp3;
50377 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50378 }
50379 {
50380 PyThreadState* __tstate = wxPyBeginAllowThreads();
50381 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50382 wxPyEndAllowThreads(__tstate);
50383 if (PyErr_Occurred()) SWIG_fail;
50384 }
50385 {
50386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50387 }
50388 return resultobj;
50389 fail:
50390 return NULL;
50391 }
50392
50393
50394 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50395 PyObject *resultobj = 0;
50396 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50397 wxGBPosition result;
50398 void *argp1 = 0 ;
50399 int res1 = 0 ;
50400 PyObject *swig_obj[1] ;
50401
50402 if (!args) SWIG_fail;
50403 swig_obj[0] = args;
50404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50405 if (!SWIG_IsOK(res1)) {
50406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50407 }
50408 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50409 {
50410 PyThreadState* __tstate = wxPyBeginAllowThreads();
50411 result = wxGBSizerItem_GetEndPos(arg1);
50412 wxPyEndAllowThreads(__tstate);
50413 if (PyErr_Occurred()) SWIG_fail;
50414 }
50415 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50416 return resultobj;
50417 fail:
50418 return NULL;
50419 }
50420
50421
50422 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50423 PyObject *resultobj = 0;
50424 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50425 wxGridBagSizer *result = 0 ;
50426 void *argp1 = 0 ;
50427 int res1 = 0 ;
50428 PyObject *swig_obj[1] ;
50429
50430 if (!args) SWIG_fail;
50431 swig_obj[0] = args;
50432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50433 if (!SWIG_IsOK(res1)) {
50434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50435 }
50436 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50437 {
50438 PyThreadState* __tstate = wxPyBeginAllowThreads();
50439 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50440 wxPyEndAllowThreads(__tstate);
50441 if (PyErr_Occurred()) SWIG_fail;
50442 }
50443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50444 return resultobj;
50445 fail:
50446 return NULL;
50447 }
50448
50449
50450 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50451 PyObject *resultobj = 0;
50452 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50453 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50454 void *argp1 = 0 ;
50455 int res1 = 0 ;
50456 void *argp2 = 0 ;
50457 int res2 = 0 ;
50458 PyObject * obj0 = 0 ;
50459 PyObject * obj1 = 0 ;
50460 char * kwnames[] = {
50461 (char *) "self",(char *) "sizer", NULL
50462 };
50463
50464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50466 if (!SWIG_IsOK(res1)) {
50467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50468 }
50469 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50471 if (!SWIG_IsOK(res2)) {
50472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50473 }
50474 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 (arg1)->SetGBSizer(arg2);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_Py_Void();
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50489 PyObject *obj;
50490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50491 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50492 return SWIG_Py_Void();
50493 }
50494
50495 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50496 return SWIG_Python_InitShadowInstance(args);
50497 }
50498
50499 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50500 PyObject *resultobj = 0;
50501 int arg1 = (int) 0 ;
50502 int arg2 = (int) 0 ;
50503 wxGridBagSizer *result = 0 ;
50504 int val1 ;
50505 int ecode1 = 0 ;
50506 int val2 ;
50507 int ecode2 = 0 ;
50508 PyObject * obj0 = 0 ;
50509 PyObject * obj1 = 0 ;
50510 char * kwnames[] = {
50511 (char *) "vgap",(char *) "hgap", NULL
50512 };
50513
50514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50515 if (obj0) {
50516 ecode1 = SWIG_AsVal_int(obj0, &val1);
50517 if (!SWIG_IsOK(ecode1)) {
50518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50519 }
50520 arg1 = static_cast< int >(val1);
50521 }
50522 if (obj1) {
50523 ecode2 = SWIG_AsVal_int(obj1, &val2);
50524 if (!SWIG_IsOK(ecode2)) {
50525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50526 }
50527 arg2 = static_cast< int >(val2);
50528 }
50529 {
50530 PyThreadState* __tstate = wxPyBeginAllowThreads();
50531 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50532 wxPyEndAllowThreads(__tstate);
50533 if (PyErr_Occurred()) SWIG_fail;
50534 }
50535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50536 return resultobj;
50537 fail:
50538 return NULL;
50539 }
50540
50541
50542 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50543 PyObject *resultobj = 0;
50544 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50545 PyObject *arg2 = (PyObject *) 0 ;
50546 wxGBPosition *arg3 = 0 ;
50547 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50548 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50549 int arg5 = (int) 0 ;
50550 int arg6 = (int) 0 ;
50551 PyObject *arg7 = (PyObject *) NULL ;
50552 wxGBSizerItem *result = 0 ;
50553 void *argp1 = 0 ;
50554 int res1 = 0 ;
50555 wxGBPosition temp3 ;
50556 wxGBSpan temp4 ;
50557 int val5 ;
50558 int ecode5 = 0 ;
50559 int val6 ;
50560 int ecode6 = 0 ;
50561 PyObject * obj0 = 0 ;
50562 PyObject * obj1 = 0 ;
50563 PyObject * obj2 = 0 ;
50564 PyObject * obj3 = 0 ;
50565 PyObject * obj4 = 0 ;
50566 PyObject * obj5 = 0 ;
50567 PyObject * obj6 = 0 ;
50568 char * kwnames[] = {
50569 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50570 };
50571
50572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50574 if (!SWIG_IsOK(res1)) {
50575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50576 }
50577 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50578 arg2 = obj1;
50579 {
50580 arg3 = &temp3;
50581 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50582 }
50583 if (obj3) {
50584 {
50585 arg4 = &temp4;
50586 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50587 }
50588 }
50589 if (obj4) {
50590 ecode5 = SWIG_AsVal_int(obj4, &val5);
50591 if (!SWIG_IsOK(ecode5)) {
50592 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50593 }
50594 arg5 = static_cast< int >(val5);
50595 }
50596 if (obj5) {
50597 ecode6 = SWIG_AsVal_int(obj5, &val6);
50598 if (!SWIG_IsOK(ecode6)) {
50599 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50600 }
50601 arg6 = static_cast< int >(val6);
50602 }
50603 if (obj6) {
50604 arg7 = obj6;
50605 }
50606 {
50607 PyThreadState* __tstate = wxPyBeginAllowThreads();
50608 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50609 wxPyEndAllowThreads(__tstate);
50610 if (PyErr_Occurred()) SWIG_fail;
50611 }
50612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50613 return resultobj;
50614 fail:
50615 return NULL;
50616 }
50617
50618
50619 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50620 PyObject *resultobj = 0;
50621 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50622 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50623 wxGBSizerItem *result = 0 ;
50624 void *argp1 = 0 ;
50625 int res1 = 0 ;
50626 int res2 = 0 ;
50627 PyObject * obj0 = 0 ;
50628 PyObject * obj1 = 0 ;
50629 char * kwnames[] = {
50630 (char *) "self",(char *) "item", NULL
50631 };
50632
50633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50635 if (!SWIG_IsOK(res1)) {
50636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50637 }
50638 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50639 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50640 if (!SWIG_IsOK(res2)) {
50641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50642 }
50643 {
50644 PyThreadState* __tstate = wxPyBeginAllowThreads();
50645 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50646 wxPyEndAllowThreads(__tstate);
50647 if (PyErr_Occurred()) SWIG_fail;
50648 }
50649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50650 return resultobj;
50651 fail:
50652 return NULL;
50653 }
50654
50655
50656 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50657 PyObject *resultobj = 0;
50658 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50659 int arg2 ;
50660 int arg3 ;
50661 wxSize result;
50662 void *argp1 = 0 ;
50663 int res1 = 0 ;
50664 int val2 ;
50665 int ecode2 = 0 ;
50666 int val3 ;
50667 int ecode3 = 0 ;
50668 PyObject * obj0 = 0 ;
50669 PyObject * obj1 = 0 ;
50670 PyObject * obj2 = 0 ;
50671 char * kwnames[] = {
50672 (char *) "self",(char *) "row",(char *) "col", NULL
50673 };
50674
50675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50677 if (!SWIG_IsOK(res1)) {
50678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50679 }
50680 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50681 ecode2 = SWIG_AsVal_int(obj1, &val2);
50682 if (!SWIG_IsOK(ecode2)) {
50683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50684 }
50685 arg2 = static_cast< int >(val2);
50686 ecode3 = SWIG_AsVal_int(obj2, &val3);
50687 if (!SWIG_IsOK(ecode3)) {
50688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50689 }
50690 arg3 = static_cast< int >(val3);
50691 {
50692 PyThreadState* __tstate = wxPyBeginAllowThreads();
50693 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50694 wxPyEndAllowThreads(__tstate);
50695 if (PyErr_Occurred()) SWIG_fail;
50696 }
50697 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50698 return resultobj;
50699 fail:
50700 return NULL;
50701 }
50702
50703
50704 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50705 PyObject *resultobj = 0;
50706 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50707 wxSize result;
50708 void *argp1 = 0 ;
50709 int res1 = 0 ;
50710 PyObject *swig_obj[1] ;
50711
50712 if (!args) SWIG_fail;
50713 swig_obj[0] = args;
50714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50715 if (!SWIG_IsOK(res1)) {
50716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50717 }
50718 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50719 {
50720 PyThreadState* __tstate = wxPyBeginAllowThreads();
50721 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50722 wxPyEndAllowThreads(__tstate);
50723 if (PyErr_Occurred()) SWIG_fail;
50724 }
50725 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50726 return resultobj;
50727 fail:
50728 return NULL;
50729 }
50730
50731
50732 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50733 PyObject *resultobj = 0;
50734 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50735 wxSize *arg2 = 0 ;
50736 void *argp1 = 0 ;
50737 int res1 = 0 ;
50738 wxSize temp2 ;
50739 PyObject * obj0 = 0 ;
50740 PyObject * obj1 = 0 ;
50741 char * kwnames[] = {
50742 (char *) "self",(char *) "sz", NULL
50743 };
50744
50745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50747 if (!SWIG_IsOK(res1)) {
50748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50749 }
50750 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50751 {
50752 arg2 = &temp2;
50753 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50754 }
50755 {
50756 PyThreadState* __tstate = wxPyBeginAllowThreads();
50757 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50758 wxPyEndAllowThreads(__tstate);
50759 if (PyErr_Occurred()) SWIG_fail;
50760 }
50761 resultobj = SWIG_Py_Void();
50762 return resultobj;
50763 fail:
50764 return NULL;
50765 }
50766
50767
50768 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50769 PyObject *resultobj = 0;
50770 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50771 wxWindow *arg2 = (wxWindow *) 0 ;
50772 wxGBPosition result;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 void *argp2 = 0 ;
50776 int res2 = 0 ;
50777
50778 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50780 if (!SWIG_IsOK(res1)) {
50781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50782 }
50783 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50784 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50785 if (!SWIG_IsOK(res2)) {
50786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50787 }
50788 arg2 = reinterpret_cast< wxWindow * >(argp2);
50789 {
50790 PyThreadState* __tstate = wxPyBeginAllowThreads();
50791 result = (arg1)->GetItemPosition(arg2);
50792 wxPyEndAllowThreads(__tstate);
50793 if (PyErr_Occurred()) SWIG_fail;
50794 }
50795 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50796 return resultobj;
50797 fail:
50798 return NULL;
50799 }
50800
50801
50802 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50803 PyObject *resultobj = 0;
50804 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50805 wxSizer *arg2 = (wxSizer *) 0 ;
50806 wxGBPosition result;
50807 void *argp1 = 0 ;
50808 int res1 = 0 ;
50809 void *argp2 = 0 ;
50810 int res2 = 0 ;
50811
50812 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50814 if (!SWIG_IsOK(res1)) {
50815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50816 }
50817 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50818 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50819 if (!SWIG_IsOK(res2)) {
50820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50821 }
50822 arg2 = reinterpret_cast< wxSizer * >(argp2);
50823 {
50824 PyThreadState* __tstate = wxPyBeginAllowThreads();
50825 result = (arg1)->GetItemPosition(arg2);
50826 wxPyEndAllowThreads(__tstate);
50827 if (PyErr_Occurred()) SWIG_fail;
50828 }
50829 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50830 return resultobj;
50831 fail:
50832 return NULL;
50833 }
50834
50835
50836 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50837 PyObject *resultobj = 0;
50838 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50839 size_t arg2 ;
50840 wxGBPosition result;
50841 void *argp1 = 0 ;
50842 int res1 = 0 ;
50843 size_t val2 ;
50844 int ecode2 = 0 ;
50845
50846 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50848 if (!SWIG_IsOK(res1)) {
50849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50850 }
50851 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50852 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50853 if (!SWIG_IsOK(ecode2)) {
50854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50855 }
50856 arg2 = static_cast< size_t >(val2);
50857 {
50858 PyThreadState* __tstate = wxPyBeginAllowThreads();
50859 result = (arg1)->GetItemPosition(arg2);
50860 wxPyEndAllowThreads(__tstate);
50861 if (PyErr_Occurred()) SWIG_fail;
50862 }
50863 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50864 return resultobj;
50865 fail:
50866 return NULL;
50867 }
50868
50869
50870 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50871 int argc;
50872 PyObject *argv[3];
50873
50874 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50875 --argc;
50876 if (argc == 2) {
50877 int _v = 0;
50878 {
50879 void *vptr = 0;
50880 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50881 _v = SWIG_CheckState(res);
50882 }
50883 if (!_v) goto check_1;
50884 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50885 }
50886 check_1:
50887
50888 if (argc == 2) {
50889 int _v = 0;
50890 {
50891 void *vptr = 0;
50892 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50893 _v = SWIG_CheckState(res);
50894 }
50895 if (!_v) goto check_2;
50896 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50897 }
50898 check_2:
50899
50900 if (argc == 2) {
50901 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50902 }
50903
50904 fail:
50905 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50911 PyObject *resultobj = 0;
50912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50913 wxWindow *arg2 = (wxWindow *) 0 ;
50914 wxGBPosition *arg3 = 0 ;
50915 bool result;
50916 void *argp1 = 0 ;
50917 int res1 = 0 ;
50918 void *argp2 = 0 ;
50919 int res2 = 0 ;
50920 wxGBPosition temp3 ;
50921
50922 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50924 if (!SWIG_IsOK(res1)) {
50925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50926 }
50927 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50928 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50929 if (!SWIG_IsOK(res2)) {
50930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50931 }
50932 arg2 = reinterpret_cast< wxWindow * >(argp2);
50933 {
50934 arg3 = &temp3;
50935 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50936 }
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 {
50944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50945 }
50946 return resultobj;
50947 fail:
50948 return NULL;
50949 }
50950
50951
50952 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50953 PyObject *resultobj = 0;
50954 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50955 wxSizer *arg2 = (wxSizer *) 0 ;
50956 wxGBPosition *arg3 = 0 ;
50957 bool result;
50958 void *argp1 = 0 ;
50959 int res1 = 0 ;
50960 void *argp2 = 0 ;
50961 int res2 = 0 ;
50962 wxGBPosition temp3 ;
50963
50964 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50966 if (!SWIG_IsOK(res1)) {
50967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50968 }
50969 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50970 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50971 if (!SWIG_IsOK(res2)) {
50972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50973 }
50974 arg2 = reinterpret_cast< wxSizer * >(argp2);
50975 {
50976 arg3 = &temp3;
50977 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50978 }
50979 {
50980 PyThreadState* __tstate = wxPyBeginAllowThreads();
50981 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50982 wxPyEndAllowThreads(__tstate);
50983 if (PyErr_Occurred()) SWIG_fail;
50984 }
50985 {
50986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50987 }
50988 return resultobj;
50989 fail:
50990 return NULL;
50991 }
50992
50993
50994 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50995 PyObject *resultobj = 0;
50996 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50997 size_t arg2 ;
50998 wxGBPosition *arg3 = 0 ;
50999 bool result;
51000 void *argp1 = 0 ;
51001 int res1 = 0 ;
51002 size_t val2 ;
51003 int ecode2 = 0 ;
51004 wxGBPosition temp3 ;
51005
51006 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51008 if (!SWIG_IsOK(res1)) {
51009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51010 }
51011 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51012 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51013 if (!SWIG_IsOK(ecode2)) {
51014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51015 }
51016 arg2 = static_cast< size_t >(val2);
51017 {
51018 arg3 = &temp3;
51019 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51020 }
51021 {
51022 PyThreadState* __tstate = wxPyBeginAllowThreads();
51023 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51024 wxPyEndAllowThreads(__tstate);
51025 if (PyErr_Occurred()) SWIG_fail;
51026 }
51027 {
51028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51029 }
51030 return resultobj;
51031 fail:
51032 return NULL;
51033 }
51034
51035
51036 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51037 int argc;
51038 PyObject *argv[4];
51039
51040 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51041 --argc;
51042 if (argc == 3) {
51043 int _v = 0;
51044 {
51045 void *vptr = 0;
51046 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51047 _v = SWIG_CheckState(res);
51048 }
51049 if (!_v) goto check_1;
51050 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51051 }
51052 check_1:
51053
51054 if (argc == 3) {
51055 int _v = 0;
51056 {
51057 void *vptr = 0;
51058 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51059 _v = SWIG_CheckState(res);
51060 }
51061 if (!_v) goto check_2;
51062 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51063 }
51064 check_2:
51065
51066 if (argc == 3) {
51067 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51068 }
51069
51070 fail:
51071 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51072 return NULL;
51073 }
51074
51075
51076 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51077 PyObject *resultobj = 0;
51078 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51079 wxWindow *arg2 = (wxWindow *) 0 ;
51080 wxGBSpan result;
51081 void *argp1 = 0 ;
51082 int res1 = 0 ;
51083 void *argp2 = 0 ;
51084 int res2 = 0 ;
51085
51086 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51088 if (!SWIG_IsOK(res1)) {
51089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51090 }
51091 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51093 if (!SWIG_IsOK(res2)) {
51094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51095 }
51096 arg2 = reinterpret_cast< wxWindow * >(argp2);
51097 {
51098 PyThreadState* __tstate = wxPyBeginAllowThreads();
51099 result = (arg1)->GetItemSpan(arg2);
51100 wxPyEndAllowThreads(__tstate);
51101 if (PyErr_Occurred()) SWIG_fail;
51102 }
51103 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51104 return resultobj;
51105 fail:
51106 return NULL;
51107 }
51108
51109
51110 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51111 PyObject *resultobj = 0;
51112 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51113 wxSizer *arg2 = (wxSizer *) 0 ;
51114 wxGBSpan result;
51115 void *argp1 = 0 ;
51116 int res1 = 0 ;
51117 void *argp2 = 0 ;
51118 int res2 = 0 ;
51119
51120 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51122 if (!SWIG_IsOK(res1)) {
51123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51124 }
51125 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51126 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51127 if (!SWIG_IsOK(res2)) {
51128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51129 }
51130 arg2 = reinterpret_cast< wxSizer * >(argp2);
51131 {
51132 PyThreadState* __tstate = wxPyBeginAllowThreads();
51133 result = (arg1)->GetItemSpan(arg2);
51134 wxPyEndAllowThreads(__tstate);
51135 if (PyErr_Occurred()) SWIG_fail;
51136 }
51137 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51138 return resultobj;
51139 fail:
51140 return NULL;
51141 }
51142
51143
51144 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51145 PyObject *resultobj = 0;
51146 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51147 size_t arg2 ;
51148 wxGBSpan result;
51149 void *argp1 = 0 ;
51150 int res1 = 0 ;
51151 size_t val2 ;
51152 int ecode2 = 0 ;
51153
51154 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51156 if (!SWIG_IsOK(res1)) {
51157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51158 }
51159 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51160 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51161 if (!SWIG_IsOK(ecode2)) {
51162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51163 }
51164 arg2 = static_cast< size_t >(val2);
51165 {
51166 PyThreadState* __tstate = wxPyBeginAllowThreads();
51167 result = (arg1)->GetItemSpan(arg2);
51168 wxPyEndAllowThreads(__tstate);
51169 if (PyErr_Occurred()) SWIG_fail;
51170 }
51171 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51172 return resultobj;
51173 fail:
51174 return NULL;
51175 }
51176
51177
51178 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51179 int argc;
51180 PyObject *argv[3];
51181
51182 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51183 --argc;
51184 if (argc == 2) {
51185 int _v = 0;
51186 {
51187 void *vptr = 0;
51188 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51189 _v = SWIG_CheckState(res);
51190 }
51191 if (!_v) goto check_1;
51192 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51193 }
51194 check_1:
51195
51196 if (argc == 2) {
51197 int _v = 0;
51198 {
51199 void *vptr = 0;
51200 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51201 _v = SWIG_CheckState(res);
51202 }
51203 if (!_v) goto check_2;
51204 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51205 }
51206 check_2:
51207
51208 if (argc == 2) {
51209 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51210 }
51211
51212 fail:
51213 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51214 return NULL;
51215 }
51216
51217
51218 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51219 PyObject *resultobj = 0;
51220 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51221 wxWindow *arg2 = (wxWindow *) 0 ;
51222 wxGBSpan *arg3 = 0 ;
51223 bool result;
51224 void *argp1 = 0 ;
51225 int res1 = 0 ;
51226 void *argp2 = 0 ;
51227 int res2 = 0 ;
51228 wxGBSpan temp3 ;
51229
51230 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51232 if (!SWIG_IsOK(res1)) {
51233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51234 }
51235 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51236 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51237 if (!SWIG_IsOK(res2)) {
51238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51239 }
51240 arg2 = reinterpret_cast< wxWindow * >(argp2);
51241 {
51242 arg3 = &temp3;
51243 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51244 }
51245 {
51246 PyThreadState* __tstate = wxPyBeginAllowThreads();
51247 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51248 wxPyEndAllowThreads(__tstate);
51249 if (PyErr_Occurred()) SWIG_fail;
51250 }
51251 {
51252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51253 }
51254 return resultobj;
51255 fail:
51256 return NULL;
51257 }
51258
51259
51260 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51261 PyObject *resultobj = 0;
51262 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51263 wxSizer *arg2 = (wxSizer *) 0 ;
51264 wxGBSpan *arg3 = 0 ;
51265 bool result;
51266 void *argp1 = 0 ;
51267 int res1 = 0 ;
51268 void *argp2 = 0 ;
51269 int res2 = 0 ;
51270 wxGBSpan temp3 ;
51271
51272 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51278 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51279 if (!SWIG_IsOK(res2)) {
51280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51281 }
51282 arg2 = reinterpret_cast< wxSizer * >(argp2);
51283 {
51284 arg3 = &temp3;
51285 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51286 }
51287 {
51288 PyThreadState* __tstate = wxPyBeginAllowThreads();
51289 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51290 wxPyEndAllowThreads(__tstate);
51291 if (PyErr_Occurred()) SWIG_fail;
51292 }
51293 {
51294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51295 }
51296 return resultobj;
51297 fail:
51298 return NULL;
51299 }
51300
51301
51302 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51303 PyObject *resultobj = 0;
51304 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51305 size_t arg2 ;
51306 wxGBSpan *arg3 = 0 ;
51307 bool result;
51308 void *argp1 = 0 ;
51309 int res1 = 0 ;
51310 size_t val2 ;
51311 int ecode2 = 0 ;
51312 wxGBSpan temp3 ;
51313
51314 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51316 if (!SWIG_IsOK(res1)) {
51317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51318 }
51319 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51320 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51321 if (!SWIG_IsOK(ecode2)) {
51322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51323 }
51324 arg2 = static_cast< size_t >(val2);
51325 {
51326 arg3 = &temp3;
51327 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51328 }
51329 {
51330 PyThreadState* __tstate = wxPyBeginAllowThreads();
51331 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51332 wxPyEndAllowThreads(__tstate);
51333 if (PyErr_Occurred()) SWIG_fail;
51334 }
51335 {
51336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51337 }
51338 return resultobj;
51339 fail:
51340 return NULL;
51341 }
51342
51343
51344 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51345 int argc;
51346 PyObject *argv[4];
51347
51348 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51349 --argc;
51350 if (argc == 3) {
51351 int _v = 0;
51352 {
51353 void *vptr = 0;
51354 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51355 _v = SWIG_CheckState(res);
51356 }
51357 if (!_v) goto check_1;
51358 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51359 }
51360 check_1:
51361
51362 if (argc == 3) {
51363 int _v = 0;
51364 {
51365 void *vptr = 0;
51366 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51367 _v = SWIG_CheckState(res);
51368 }
51369 if (!_v) goto check_2;
51370 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51371 }
51372 check_2:
51373
51374 if (argc == 3) {
51375 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51376 }
51377
51378 fail:
51379 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51380 return NULL;
51381 }
51382
51383
51384 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51385 PyObject *resultobj = 0;
51386 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51387 wxWindow *arg2 = (wxWindow *) 0 ;
51388 wxGBSizerItem *result = 0 ;
51389 void *argp1 = 0 ;
51390 int res1 = 0 ;
51391 void *argp2 = 0 ;
51392 int res2 = 0 ;
51393
51394 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51396 if (!SWIG_IsOK(res1)) {
51397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51398 }
51399 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51400 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51401 if (!SWIG_IsOK(res2)) {
51402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51403 }
51404 arg2 = reinterpret_cast< wxWindow * >(argp2);
51405 {
51406 PyThreadState* __tstate = wxPyBeginAllowThreads();
51407 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51408 wxPyEndAllowThreads(__tstate);
51409 if (PyErr_Occurred()) SWIG_fail;
51410 }
51411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51412 return resultobj;
51413 fail:
51414 return NULL;
51415 }
51416
51417
51418 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51419 PyObject *resultobj = 0;
51420 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51421 wxSizer *arg2 = (wxSizer *) 0 ;
51422 wxGBSizerItem *result = 0 ;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 void *argp2 = 0 ;
51426 int res2 = 0 ;
51427
51428 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51430 if (!SWIG_IsOK(res1)) {
51431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51432 }
51433 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51434 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51435 if (!SWIG_IsOK(res2)) {
51436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51437 }
51438 arg2 = reinterpret_cast< wxSizer * >(argp2);
51439 {
51440 PyThreadState* __tstate = wxPyBeginAllowThreads();
51441 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51442 wxPyEndAllowThreads(__tstate);
51443 if (PyErr_Occurred()) SWIG_fail;
51444 }
51445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51446 return resultobj;
51447 fail:
51448 return NULL;
51449 }
51450
51451
51452 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51453 int argc;
51454 PyObject *argv[3];
51455
51456 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51457 --argc;
51458 if (argc == 2) {
51459 int _v = 0;
51460 {
51461 void *vptr = 0;
51462 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51463 _v = SWIG_CheckState(res);
51464 }
51465 if (!_v) goto check_1;
51466 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51467 }
51468 check_1:
51469
51470 if (argc == 2) {
51471 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51472 }
51473
51474 fail:
51475 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51476 return NULL;
51477 }
51478
51479
51480 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51481 PyObject *resultobj = 0;
51482 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51483 wxGBPosition *arg2 = 0 ;
51484 wxGBSizerItem *result = 0 ;
51485 void *argp1 = 0 ;
51486 int res1 = 0 ;
51487 wxGBPosition temp2 ;
51488 PyObject * obj0 = 0 ;
51489 PyObject * obj1 = 0 ;
51490 char * kwnames[] = {
51491 (char *) "self",(char *) "pos", NULL
51492 };
51493
51494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51496 if (!SWIG_IsOK(res1)) {
51497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51498 }
51499 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51500 {
51501 arg2 = &temp2;
51502 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51503 }
51504 {
51505 PyThreadState* __tstate = wxPyBeginAllowThreads();
51506 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51507 wxPyEndAllowThreads(__tstate);
51508 if (PyErr_Occurred()) SWIG_fail;
51509 }
51510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51511 return resultobj;
51512 fail:
51513 return NULL;
51514 }
51515
51516
51517 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51518 PyObject *resultobj = 0;
51519 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51520 wxPoint *arg2 = 0 ;
51521 wxGBSizerItem *result = 0 ;
51522 void *argp1 = 0 ;
51523 int res1 = 0 ;
51524 wxPoint temp2 ;
51525 PyObject * obj0 = 0 ;
51526 PyObject * obj1 = 0 ;
51527 char * kwnames[] = {
51528 (char *) "self",(char *) "pt", NULL
51529 };
51530
51531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51533 if (!SWIG_IsOK(res1)) {
51534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51535 }
51536 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51537 {
51538 arg2 = &temp2;
51539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51540 }
51541 {
51542 PyThreadState* __tstate = wxPyBeginAllowThreads();
51543 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51544 wxPyEndAllowThreads(__tstate);
51545 if (PyErr_Occurred()) SWIG_fail;
51546 }
51547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51548 return resultobj;
51549 fail:
51550 return NULL;
51551 }
51552
51553
51554 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51555 PyObject *resultobj = 0;
51556 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51557 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51558 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51559 bool result;
51560 void *argp1 = 0 ;
51561 int res1 = 0 ;
51562 void *argp2 = 0 ;
51563 int res2 = 0 ;
51564 void *argp3 = 0 ;
51565 int res3 = 0 ;
51566 PyObject * obj0 = 0 ;
51567 PyObject * obj1 = 0 ;
51568 PyObject * obj2 = 0 ;
51569 char * kwnames[] = {
51570 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51571 };
51572
51573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51575 if (!SWIG_IsOK(res1)) {
51576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51577 }
51578 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51580 if (!SWIG_IsOK(res2)) {
51581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51582 }
51583 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51584 if (obj2) {
51585 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51586 if (!SWIG_IsOK(res3)) {
51587 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51588 }
51589 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51590 }
51591 {
51592 PyThreadState* __tstate = wxPyBeginAllowThreads();
51593 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51594 wxPyEndAllowThreads(__tstate);
51595 if (PyErr_Occurred()) SWIG_fail;
51596 }
51597 {
51598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51599 }
51600 return resultobj;
51601 fail:
51602 return NULL;
51603 }
51604
51605
51606 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51607 PyObject *resultobj = 0;
51608 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51609 wxGBPosition *arg2 = 0 ;
51610 wxGBSpan *arg3 = 0 ;
51611 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51612 bool result;
51613 void *argp1 = 0 ;
51614 int res1 = 0 ;
51615 wxGBPosition temp2 ;
51616 wxGBSpan temp3 ;
51617 void *argp4 = 0 ;
51618 int res4 = 0 ;
51619 PyObject * obj0 = 0 ;
51620 PyObject * obj1 = 0 ;
51621 PyObject * obj2 = 0 ;
51622 PyObject * obj3 = 0 ;
51623 char * kwnames[] = {
51624 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51625 };
51626
51627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51629 if (!SWIG_IsOK(res1)) {
51630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51631 }
51632 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51633 {
51634 arg2 = &temp2;
51635 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51636 }
51637 {
51638 arg3 = &temp3;
51639 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51640 }
51641 if (obj3) {
51642 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51643 if (!SWIG_IsOK(res4)) {
51644 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51645 }
51646 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51647 }
51648 {
51649 PyThreadState* __tstate = wxPyBeginAllowThreads();
51650 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51651 wxPyEndAllowThreads(__tstate);
51652 if (PyErr_Occurred()) SWIG_fail;
51653 }
51654 {
51655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51656 }
51657 return resultobj;
51658 fail:
51659 return NULL;
51660 }
51661
51662
51663 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51664 PyObject *obj;
51665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51666 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51667 return SWIG_Py_Void();
51668 }
51669
51670 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51671 return SWIG_Python_InitShadowInstance(args);
51672 }
51673
51674 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51675 PyObject *resultobj = 0;
51676 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51677 wxRelationship arg2 ;
51678 wxWindow *arg3 = (wxWindow *) 0 ;
51679 wxEdge arg4 ;
51680 int arg5 = (int) 0 ;
51681 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51682 void *argp1 = 0 ;
51683 int res1 = 0 ;
51684 int val2 ;
51685 int ecode2 = 0 ;
51686 void *argp3 = 0 ;
51687 int res3 = 0 ;
51688 int val4 ;
51689 int ecode4 = 0 ;
51690 int val5 ;
51691 int ecode5 = 0 ;
51692 int val6 ;
51693 int ecode6 = 0 ;
51694 PyObject * obj0 = 0 ;
51695 PyObject * obj1 = 0 ;
51696 PyObject * obj2 = 0 ;
51697 PyObject * obj3 = 0 ;
51698 PyObject * obj4 = 0 ;
51699 PyObject * obj5 = 0 ;
51700 char * kwnames[] = {
51701 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51702 };
51703
51704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51706 if (!SWIG_IsOK(res1)) {
51707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51708 }
51709 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51710 ecode2 = SWIG_AsVal_int(obj1, &val2);
51711 if (!SWIG_IsOK(ecode2)) {
51712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51713 }
51714 arg2 = static_cast< wxRelationship >(val2);
51715 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51716 if (!SWIG_IsOK(res3)) {
51717 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51718 }
51719 arg3 = reinterpret_cast< wxWindow * >(argp3);
51720 ecode4 = SWIG_AsVal_int(obj3, &val4);
51721 if (!SWIG_IsOK(ecode4)) {
51722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51723 }
51724 arg4 = static_cast< wxEdge >(val4);
51725 if (obj4) {
51726 ecode5 = SWIG_AsVal_int(obj4, &val5);
51727 if (!SWIG_IsOK(ecode5)) {
51728 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51729 }
51730 arg5 = static_cast< int >(val5);
51731 }
51732 if (obj5) {
51733 ecode6 = SWIG_AsVal_int(obj5, &val6);
51734 if (!SWIG_IsOK(ecode6)) {
51735 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51736 }
51737 arg6 = static_cast< int >(val6);
51738 }
51739 {
51740 PyThreadState* __tstate = wxPyBeginAllowThreads();
51741 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51742 wxPyEndAllowThreads(__tstate);
51743 if (PyErr_Occurred()) SWIG_fail;
51744 }
51745 resultobj = SWIG_Py_Void();
51746 return resultobj;
51747 fail:
51748 return NULL;
51749 }
51750
51751
51752 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51753 PyObject *resultobj = 0;
51754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51755 wxWindow *arg2 = (wxWindow *) 0 ;
51756 int arg3 = (int) 0 ;
51757 void *argp1 = 0 ;
51758 int res1 = 0 ;
51759 void *argp2 = 0 ;
51760 int res2 = 0 ;
51761 int val3 ;
51762 int ecode3 = 0 ;
51763 PyObject * obj0 = 0 ;
51764 PyObject * obj1 = 0 ;
51765 PyObject * obj2 = 0 ;
51766 char * kwnames[] = {
51767 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51768 };
51769
51770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51772 if (!SWIG_IsOK(res1)) {
51773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51774 }
51775 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51777 if (!SWIG_IsOK(res2)) {
51778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51779 }
51780 arg2 = reinterpret_cast< wxWindow * >(argp2);
51781 if (obj2) {
51782 ecode3 = SWIG_AsVal_int(obj2, &val3);
51783 if (!SWIG_IsOK(ecode3)) {
51784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51785 }
51786 arg3 = static_cast< int >(val3);
51787 }
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 (arg1)->LeftOf(arg2,arg3);
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_Py_Void();
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51802 PyObject *resultobj = 0;
51803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51804 wxWindow *arg2 = (wxWindow *) 0 ;
51805 int arg3 = (int) 0 ;
51806 void *argp1 = 0 ;
51807 int res1 = 0 ;
51808 void *argp2 = 0 ;
51809 int res2 = 0 ;
51810 int val3 ;
51811 int ecode3 = 0 ;
51812 PyObject * obj0 = 0 ;
51813 PyObject * obj1 = 0 ;
51814 PyObject * obj2 = 0 ;
51815 char * kwnames[] = {
51816 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51817 };
51818
51819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51821 if (!SWIG_IsOK(res1)) {
51822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51823 }
51824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51826 if (!SWIG_IsOK(res2)) {
51827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51828 }
51829 arg2 = reinterpret_cast< wxWindow * >(argp2);
51830 if (obj2) {
51831 ecode3 = SWIG_AsVal_int(obj2, &val3);
51832 if (!SWIG_IsOK(ecode3)) {
51833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51834 }
51835 arg3 = static_cast< int >(val3);
51836 }
51837 {
51838 PyThreadState* __tstate = wxPyBeginAllowThreads();
51839 (arg1)->RightOf(arg2,arg3);
51840 wxPyEndAllowThreads(__tstate);
51841 if (PyErr_Occurred()) SWIG_fail;
51842 }
51843 resultobj = SWIG_Py_Void();
51844 return resultobj;
51845 fail:
51846 return NULL;
51847 }
51848
51849
51850 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51851 PyObject *resultobj = 0;
51852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51853 wxWindow *arg2 = (wxWindow *) 0 ;
51854 int arg3 = (int) 0 ;
51855 void *argp1 = 0 ;
51856 int res1 = 0 ;
51857 void *argp2 = 0 ;
51858 int res2 = 0 ;
51859 int val3 ;
51860 int ecode3 = 0 ;
51861 PyObject * obj0 = 0 ;
51862 PyObject * obj1 = 0 ;
51863 PyObject * obj2 = 0 ;
51864 char * kwnames[] = {
51865 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51866 };
51867
51868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51870 if (!SWIG_IsOK(res1)) {
51871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51872 }
51873 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51875 if (!SWIG_IsOK(res2)) {
51876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51877 }
51878 arg2 = reinterpret_cast< wxWindow * >(argp2);
51879 if (obj2) {
51880 ecode3 = SWIG_AsVal_int(obj2, &val3);
51881 if (!SWIG_IsOK(ecode3)) {
51882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51883 }
51884 arg3 = static_cast< int >(val3);
51885 }
51886 {
51887 PyThreadState* __tstate = wxPyBeginAllowThreads();
51888 (arg1)->Above(arg2,arg3);
51889 wxPyEndAllowThreads(__tstate);
51890 if (PyErr_Occurred()) SWIG_fail;
51891 }
51892 resultobj = SWIG_Py_Void();
51893 return resultobj;
51894 fail:
51895 return NULL;
51896 }
51897
51898
51899 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51900 PyObject *resultobj = 0;
51901 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51902 wxWindow *arg2 = (wxWindow *) 0 ;
51903 int arg3 = (int) 0 ;
51904 void *argp1 = 0 ;
51905 int res1 = 0 ;
51906 void *argp2 = 0 ;
51907 int res2 = 0 ;
51908 int val3 ;
51909 int ecode3 = 0 ;
51910 PyObject * obj0 = 0 ;
51911 PyObject * obj1 = 0 ;
51912 PyObject * obj2 = 0 ;
51913 char * kwnames[] = {
51914 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51915 };
51916
51917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51919 if (!SWIG_IsOK(res1)) {
51920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51921 }
51922 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51924 if (!SWIG_IsOK(res2)) {
51925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51926 }
51927 arg2 = reinterpret_cast< wxWindow * >(argp2);
51928 if (obj2) {
51929 ecode3 = SWIG_AsVal_int(obj2, &val3);
51930 if (!SWIG_IsOK(ecode3)) {
51931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51932 }
51933 arg3 = static_cast< int >(val3);
51934 }
51935 {
51936 PyThreadState* __tstate = wxPyBeginAllowThreads();
51937 (arg1)->Below(arg2,arg3);
51938 wxPyEndAllowThreads(__tstate);
51939 if (PyErr_Occurred()) SWIG_fail;
51940 }
51941 resultobj = SWIG_Py_Void();
51942 return resultobj;
51943 fail:
51944 return NULL;
51945 }
51946
51947
51948 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51949 PyObject *resultobj = 0;
51950 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51951 wxWindow *arg2 = (wxWindow *) 0 ;
51952 wxEdge arg3 ;
51953 int arg4 = (int) 0 ;
51954 void *argp1 = 0 ;
51955 int res1 = 0 ;
51956 void *argp2 = 0 ;
51957 int res2 = 0 ;
51958 int val3 ;
51959 int ecode3 = 0 ;
51960 int val4 ;
51961 int ecode4 = 0 ;
51962 PyObject * obj0 = 0 ;
51963 PyObject * obj1 = 0 ;
51964 PyObject * obj2 = 0 ;
51965 PyObject * obj3 = 0 ;
51966 char * kwnames[] = {
51967 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51968 };
51969
51970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51972 if (!SWIG_IsOK(res1)) {
51973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51974 }
51975 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51977 if (!SWIG_IsOK(res2)) {
51978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51979 }
51980 arg2 = reinterpret_cast< wxWindow * >(argp2);
51981 ecode3 = SWIG_AsVal_int(obj2, &val3);
51982 if (!SWIG_IsOK(ecode3)) {
51983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51984 }
51985 arg3 = static_cast< wxEdge >(val3);
51986 if (obj3) {
51987 ecode4 = SWIG_AsVal_int(obj3, &val4);
51988 if (!SWIG_IsOK(ecode4)) {
51989 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51990 }
51991 arg4 = static_cast< int >(val4);
51992 }
51993 {
51994 PyThreadState* __tstate = wxPyBeginAllowThreads();
51995 (arg1)->SameAs(arg2,arg3,arg4);
51996 wxPyEndAllowThreads(__tstate);
51997 if (PyErr_Occurred()) SWIG_fail;
51998 }
51999 resultobj = SWIG_Py_Void();
52000 return resultobj;
52001 fail:
52002 return NULL;
52003 }
52004
52005
52006 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52007 PyObject *resultobj = 0;
52008 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52009 wxWindow *arg2 = (wxWindow *) 0 ;
52010 wxEdge arg3 ;
52011 int arg4 ;
52012 void *argp1 = 0 ;
52013 int res1 = 0 ;
52014 void *argp2 = 0 ;
52015 int res2 = 0 ;
52016 int val3 ;
52017 int ecode3 = 0 ;
52018 int val4 ;
52019 int ecode4 = 0 ;
52020 PyObject * obj0 = 0 ;
52021 PyObject * obj1 = 0 ;
52022 PyObject * obj2 = 0 ;
52023 PyObject * obj3 = 0 ;
52024 char * kwnames[] = {
52025 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52026 };
52027
52028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52030 if (!SWIG_IsOK(res1)) {
52031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52032 }
52033 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52035 if (!SWIG_IsOK(res2)) {
52036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52037 }
52038 arg2 = reinterpret_cast< wxWindow * >(argp2);
52039 ecode3 = SWIG_AsVal_int(obj2, &val3);
52040 if (!SWIG_IsOK(ecode3)) {
52041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52042 }
52043 arg3 = static_cast< wxEdge >(val3);
52044 ecode4 = SWIG_AsVal_int(obj3, &val4);
52045 if (!SWIG_IsOK(ecode4)) {
52046 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52047 }
52048 arg4 = static_cast< int >(val4);
52049 {
52050 PyThreadState* __tstate = wxPyBeginAllowThreads();
52051 (arg1)->PercentOf(arg2,arg3,arg4);
52052 wxPyEndAllowThreads(__tstate);
52053 if (PyErr_Occurred()) SWIG_fail;
52054 }
52055 resultobj = SWIG_Py_Void();
52056 return resultobj;
52057 fail:
52058 return NULL;
52059 }
52060
52061
52062 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52063 PyObject *resultobj = 0;
52064 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52065 int arg2 ;
52066 void *argp1 = 0 ;
52067 int res1 = 0 ;
52068 int val2 ;
52069 int ecode2 = 0 ;
52070 PyObject * obj0 = 0 ;
52071 PyObject * obj1 = 0 ;
52072 char * kwnames[] = {
52073 (char *) "self",(char *) "val", NULL
52074 };
52075
52076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52078 if (!SWIG_IsOK(res1)) {
52079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52080 }
52081 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52082 ecode2 = SWIG_AsVal_int(obj1, &val2);
52083 if (!SWIG_IsOK(ecode2)) {
52084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52085 }
52086 arg2 = static_cast< int >(val2);
52087 {
52088 PyThreadState* __tstate = wxPyBeginAllowThreads();
52089 (arg1)->Absolute(arg2);
52090 wxPyEndAllowThreads(__tstate);
52091 if (PyErr_Occurred()) SWIG_fail;
52092 }
52093 resultobj = SWIG_Py_Void();
52094 return resultobj;
52095 fail:
52096 return NULL;
52097 }
52098
52099
52100 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52101 PyObject *resultobj = 0;
52102 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52103 void *argp1 = 0 ;
52104 int res1 = 0 ;
52105 PyObject *swig_obj[1] ;
52106
52107 if (!args) SWIG_fail;
52108 swig_obj[0] = args;
52109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52110 if (!SWIG_IsOK(res1)) {
52111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52112 }
52113 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 (arg1)->Unconstrained();
52117 wxPyEndAllowThreads(__tstate);
52118 if (PyErr_Occurred()) SWIG_fail;
52119 }
52120 resultobj = SWIG_Py_Void();
52121 return resultobj;
52122 fail:
52123 return NULL;
52124 }
52125
52126
52127 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52128 PyObject *resultobj = 0;
52129 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52130 void *argp1 = 0 ;
52131 int res1 = 0 ;
52132 PyObject *swig_obj[1] ;
52133
52134 if (!args) SWIG_fail;
52135 swig_obj[0] = args;
52136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52137 if (!SWIG_IsOK(res1)) {
52138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52139 }
52140 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52141 {
52142 PyThreadState* __tstate = wxPyBeginAllowThreads();
52143 (arg1)->AsIs();
52144 wxPyEndAllowThreads(__tstate);
52145 if (PyErr_Occurred()) SWIG_fail;
52146 }
52147 resultobj = SWIG_Py_Void();
52148 return resultobj;
52149 fail:
52150 return NULL;
52151 }
52152
52153
52154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52155 PyObject *resultobj = 0;
52156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52157 wxWindow *result = 0 ;
52158 void *argp1 = 0 ;
52159 int res1 = 0 ;
52160 PyObject *swig_obj[1] ;
52161
52162 if (!args) SWIG_fail;
52163 swig_obj[0] = args;
52164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52165 if (!SWIG_IsOK(res1)) {
52166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52167 }
52168 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52169 {
52170 PyThreadState* __tstate = wxPyBeginAllowThreads();
52171 result = (wxWindow *)(arg1)->GetOtherWindow();
52172 wxPyEndAllowThreads(__tstate);
52173 if (PyErr_Occurred()) SWIG_fail;
52174 }
52175 {
52176 resultobj = wxPyMake_wxObject(result, 0);
52177 }
52178 return resultobj;
52179 fail:
52180 return NULL;
52181 }
52182
52183
52184 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52185 PyObject *resultobj = 0;
52186 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52187 wxEdge result;
52188 void *argp1 = 0 ;
52189 int res1 = 0 ;
52190 PyObject *swig_obj[1] ;
52191
52192 if (!args) SWIG_fail;
52193 swig_obj[0] = args;
52194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52195 if (!SWIG_IsOK(res1)) {
52196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52197 }
52198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52199 {
52200 PyThreadState* __tstate = wxPyBeginAllowThreads();
52201 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52202 wxPyEndAllowThreads(__tstate);
52203 if (PyErr_Occurred()) SWIG_fail;
52204 }
52205 resultobj = SWIG_From_int(static_cast< int >(result));
52206 return resultobj;
52207 fail:
52208 return NULL;
52209 }
52210
52211
52212 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52213 PyObject *resultobj = 0;
52214 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52215 wxEdge arg2 ;
52216 void *argp1 = 0 ;
52217 int res1 = 0 ;
52218 int val2 ;
52219 int ecode2 = 0 ;
52220 PyObject * obj0 = 0 ;
52221 PyObject * obj1 = 0 ;
52222 char * kwnames[] = {
52223 (char *) "self",(char *) "which", NULL
52224 };
52225
52226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52228 if (!SWIG_IsOK(res1)) {
52229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52230 }
52231 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52232 ecode2 = SWIG_AsVal_int(obj1, &val2);
52233 if (!SWIG_IsOK(ecode2)) {
52234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52235 }
52236 arg2 = static_cast< wxEdge >(val2);
52237 {
52238 PyThreadState* __tstate = wxPyBeginAllowThreads();
52239 (arg1)->SetEdge(arg2);
52240 wxPyEndAllowThreads(__tstate);
52241 if (PyErr_Occurred()) SWIG_fail;
52242 }
52243 resultobj = SWIG_Py_Void();
52244 return resultobj;
52245 fail:
52246 return NULL;
52247 }
52248
52249
52250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52251 PyObject *resultobj = 0;
52252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52253 int arg2 ;
52254 void *argp1 = 0 ;
52255 int res1 = 0 ;
52256 int val2 ;
52257 int ecode2 = 0 ;
52258 PyObject * obj0 = 0 ;
52259 PyObject * obj1 = 0 ;
52260 char * kwnames[] = {
52261 (char *) "self",(char *) "v", NULL
52262 };
52263
52264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52266 if (!SWIG_IsOK(res1)) {
52267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52268 }
52269 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52270 ecode2 = SWIG_AsVal_int(obj1, &val2);
52271 if (!SWIG_IsOK(ecode2)) {
52272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52273 }
52274 arg2 = static_cast< int >(val2);
52275 {
52276 PyThreadState* __tstate = wxPyBeginAllowThreads();
52277 (arg1)->SetValue(arg2);
52278 wxPyEndAllowThreads(__tstate);
52279 if (PyErr_Occurred()) SWIG_fail;
52280 }
52281 resultobj = SWIG_Py_Void();
52282 return resultobj;
52283 fail:
52284 return NULL;
52285 }
52286
52287
52288 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52289 PyObject *resultobj = 0;
52290 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52291 int result;
52292 void *argp1 = 0 ;
52293 int res1 = 0 ;
52294 PyObject *swig_obj[1] ;
52295
52296 if (!args) SWIG_fail;
52297 swig_obj[0] = args;
52298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52301 }
52302 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52303 {
52304 PyThreadState* __tstate = wxPyBeginAllowThreads();
52305 result = (int)(arg1)->GetMargin();
52306 wxPyEndAllowThreads(__tstate);
52307 if (PyErr_Occurred()) SWIG_fail;
52308 }
52309 resultobj = SWIG_From_int(static_cast< int >(result));
52310 return resultobj;
52311 fail:
52312 return NULL;
52313 }
52314
52315
52316 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52317 PyObject *resultobj = 0;
52318 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52319 int arg2 ;
52320 void *argp1 = 0 ;
52321 int res1 = 0 ;
52322 int val2 ;
52323 int ecode2 = 0 ;
52324 PyObject * obj0 = 0 ;
52325 PyObject * obj1 = 0 ;
52326 char * kwnames[] = {
52327 (char *) "self",(char *) "m", NULL
52328 };
52329
52330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52332 if (!SWIG_IsOK(res1)) {
52333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52334 }
52335 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52336 ecode2 = SWIG_AsVal_int(obj1, &val2);
52337 if (!SWIG_IsOK(ecode2)) {
52338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52339 }
52340 arg2 = static_cast< int >(val2);
52341 {
52342 PyThreadState* __tstate = wxPyBeginAllowThreads();
52343 (arg1)->SetMargin(arg2);
52344 wxPyEndAllowThreads(__tstate);
52345 if (PyErr_Occurred()) SWIG_fail;
52346 }
52347 resultobj = SWIG_Py_Void();
52348 return resultobj;
52349 fail:
52350 return NULL;
52351 }
52352
52353
52354 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52355 PyObject *resultobj = 0;
52356 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52357 int result;
52358 void *argp1 = 0 ;
52359 int res1 = 0 ;
52360 PyObject *swig_obj[1] ;
52361
52362 if (!args) SWIG_fail;
52363 swig_obj[0] = args;
52364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52365 if (!SWIG_IsOK(res1)) {
52366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52367 }
52368 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52369 {
52370 PyThreadState* __tstate = wxPyBeginAllowThreads();
52371 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52372 wxPyEndAllowThreads(__tstate);
52373 if (PyErr_Occurred()) SWIG_fail;
52374 }
52375 resultobj = SWIG_From_int(static_cast< int >(result));
52376 return resultobj;
52377 fail:
52378 return NULL;
52379 }
52380
52381
52382 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52383 PyObject *resultobj = 0;
52384 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52385 int result;
52386 void *argp1 = 0 ;
52387 int res1 = 0 ;
52388 PyObject *swig_obj[1] ;
52389
52390 if (!args) SWIG_fail;
52391 swig_obj[0] = args;
52392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52395 }
52396 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52397 {
52398 PyThreadState* __tstate = wxPyBeginAllowThreads();
52399 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52400 wxPyEndAllowThreads(__tstate);
52401 if (PyErr_Occurred()) SWIG_fail;
52402 }
52403 resultobj = SWIG_From_int(static_cast< int >(result));
52404 return resultobj;
52405 fail:
52406 return NULL;
52407 }
52408
52409
52410 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52411 PyObject *resultobj = 0;
52412 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52413 int result;
52414 void *argp1 = 0 ;
52415 int res1 = 0 ;
52416 PyObject *swig_obj[1] ;
52417
52418 if (!args) SWIG_fail;
52419 swig_obj[0] = args;
52420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52421 if (!SWIG_IsOK(res1)) {
52422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52423 }
52424 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52425 {
52426 PyThreadState* __tstate = wxPyBeginAllowThreads();
52427 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52428 wxPyEndAllowThreads(__tstate);
52429 if (PyErr_Occurred()) SWIG_fail;
52430 }
52431 resultobj = SWIG_From_int(static_cast< int >(result));
52432 return resultobj;
52433 fail:
52434 return NULL;
52435 }
52436
52437
52438 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52439 PyObject *resultobj = 0;
52440 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52441 bool result;
52442 void *argp1 = 0 ;
52443 int res1 = 0 ;
52444 PyObject *swig_obj[1] ;
52445
52446 if (!args) SWIG_fail;
52447 swig_obj[0] = args;
52448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52449 if (!SWIG_IsOK(res1)) {
52450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52451 }
52452 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52453 {
52454 PyThreadState* __tstate = wxPyBeginAllowThreads();
52455 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52456 wxPyEndAllowThreads(__tstate);
52457 if (PyErr_Occurred()) SWIG_fail;
52458 }
52459 {
52460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52461 }
52462 return resultobj;
52463 fail:
52464 return NULL;
52465 }
52466
52467
52468 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52469 PyObject *resultobj = 0;
52470 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52471 bool arg2 ;
52472 void *argp1 = 0 ;
52473 int res1 = 0 ;
52474 bool val2 ;
52475 int ecode2 = 0 ;
52476 PyObject * obj0 = 0 ;
52477 PyObject * obj1 = 0 ;
52478 char * kwnames[] = {
52479 (char *) "self",(char *) "d", NULL
52480 };
52481
52482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52484 if (!SWIG_IsOK(res1)) {
52485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52486 }
52487 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52488 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52489 if (!SWIG_IsOK(ecode2)) {
52490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52491 }
52492 arg2 = static_cast< bool >(val2);
52493 {
52494 PyThreadState* __tstate = wxPyBeginAllowThreads();
52495 (arg1)->SetDone(arg2);
52496 wxPyEndAllowThreads(__tstate);
52497 if (PyErr_Occurred()) SWIG_fail;
52498 }
52499 resultobj = SWIG_Py_Void();
52500 return resultobj;
52501 fail:
52502 return NULL;
52503 }
52504
52505
52506 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52507 PyObject *resultobj = 0;
52508 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52509 wxRelationship result;
52510 void *argp1 = 0 ;
52511 int res1 = 0 ;
52512 PyObject *swig_obj[1] ;
52513
52514 if (!args) SWIG_fail;
52515 swig_obj[0] = args;
52516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52517 if (!SWIG_IsOK(res1)) {
52518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52519 }
52520 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52521 {
52522 PyThreadState* __tstate = wxPyBeginAllowThreads();
52523 result = (wxRelationship)(arg1)->GetRelationship();
52524 wxPyEndAllowThreads(__tstate);
52525 if (PyErr_Occurred()) SWIG_fail;
52526 }
52527 resultobj = SWIG_From_int(static_cast< int >(result));
52528 return resultobj;
52529 fail:
52530 return NULL;
52531 }
52532
52533
52534 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52535 PyObject *resultobj = 0;
52536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52537 wxRelationship arg2 ;
52538 void *argp1 = 0 ;
52539 int res1 = 0 ;
52540 int val2 ;
52541 int ecode2 = 0 ;
52542 PyObject * obj0 = 0 ;
52543 PyObject * obj1 = 0 ;
52544 char * kwnames[] = {
52545 (char *) "self",(char *) "r", NULL
52546 };
52547
52548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52550 if (!SWIG_IsOK(res1)) {
52551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52552 }
52553 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52554 ecode2 = SWIG_AsVal_int(obj1, &val2);
52555 if (!SWIG_IsOK(ecode2)) {
52556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52557 }
52558 arg2 = static_cast< wxRelationship >(val2);
52559 {
52560 PyThreadState* __tstate = wxPyBeginAllowThreads();
52561 (arg1)->SetRelationship(arg2);
52562 wxPyEndAllowThreads(__tstate);
52563 if (PyErr_Occurred()) SWIG_fail;
52564 }
52565 resultobj = SWIG_Py_Void();
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52573 PyObject *resultobj = 0;
52574 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52575 wxWindow *arg2 = (wxWindow *) 0 ;
52576 bool result;
52577 void *argp1 = 0 ;
52578 int res1 = 0 ;
52579 void *argp2 = 0 ;
52580 int res2 = 0 ;
52581 PyObject * obj0 = 0 ;
52582 PyObject * obj1 = 0 ;
52583 char * kwnames[] = {
52584 (char *) "self",(char *) "otherW", NULL
52585 };
52586
52587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52589 if (!SWIG_IsOK(res1)) {
52590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52591 }
52592 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52594 if (!SWIG_IsOK(res2)) {
52595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52596 }
52597 arg2 = reinterpret_cast< wxWindow * >(argp2);
52598 {
52599 PyThreadState* __tstate = wxPyBeginAllowThreads();
52600 result = (bool)(arg1)->ResetIfWin(arg2);
52601 wxPyEndAllowThreads(__tstate);
52602 if (PyErr_Occurred()) SWIG_fail;
52603 }
52604 {
52605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52606 }
52607 return resultobj;
52608 fail:
52609 return NULL;
52610 }
52611
52612
52613 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52614 PyObject *resultobj = 0;
52615 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52616 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52617 wxWindow *arg3 = (wxWindow *) 0 ;
52618 bool result;
52619 void *argp1 = 0 ;
52620 int res1 = 0 ;
52621 void *argp2 = 0 ;
52622 int res2 = 0 ;
52623 void *argp3 = 0 ;
52624 int res3 = 0 ;
52625 PyObject * obj0 = 0 ;
52626 PyObject * obj1 = 0 ;
52627 PyObject * obj2 = 0 ;
52628 char * kwnames[] = {
52629 (char *) "self",(char *) "constraints",(char *) "win", NULL
52630 };
52631
52632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52634 if (!SWIG_IsOK(res1)) {
52635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52636 }
52637 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52639 if (!SWIG_IsOK(res2)) {
52640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52641 }
52642 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52643 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52644 if (!SWIG_IsOK(res3)) {
52645 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52646 }
52647 arg3 = reinterpret_cast< wxWindow * >(argp3);
52648 {
52649 PyThreadState* __tstate = wxPyBeginAllowThreads();
52650 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52651 wxPyEndAllowThreads(__tstate);
52652 if (PyErr_Occurred()) SWIG_fail;
52653 }
52654 {
52655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52656 }
52657 return resultobj;
52658 fail:
52659 return NULL;
52660 }
52661
52662
52663 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52664 PyObject *resultobj = 0;
52665 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52666 wxEdge arg2 ;
52667 wxWindow *arg3 = (wxWindow *) 0 ;
52668 wxWindow *arg4 = (wxWindow *) 0 ;
52669 int result;
52670 void *argp1 = 0 ;
52671 int res1 = 0 ;
52672 int val2 ;
52673 int ecode2 = 0 ;
52674 void *argp3 = 0 ;
52675 int res3 = 0 ;
52676 void *argp4 = 0 ;
52677 int res4 = 0 ;
52678 PyObject * obj0 = 0 ;
52679 PyObject * obj1 = 0 ;
52680 PyObject * obj2 = 0 ;
52681 PyObject * obj3 = 0 ;
52682 char * kwnames[] = {
52683 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52684 };
52685
52686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52688 if (!SWIG_IsOK(res1)) {
52689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52690 }
52691 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52692 ecode2 = SWIG_AsVal_int(obj1, &val2);
52693 if (!SWIG_IsOK(ecode2)) {
52694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52695 }
52696 arg2 = static_cast< wxEdge >(val2);
52697 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52698 if (!SWIG_IsOK(res3)) {
52699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52700 }
52701 arg3 = reinterpret_cast< wxWindow * >(argp3);
52702 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52703 if (!SWIG_IsOK(res4)) {
52704 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52705 }
52706 arg4 = reinterpret_cast< wxWindow * >(argp4);
52707 {
52708 PyThreadState* __tstate = wxPyBeginAllowThreads();
52709 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52710 wxPyEndAllowThreads(__tstate);
52711 if (PyErr_Occurred()) SWIG_fail;
52712 }
52713 resultobj = SWIG_From_int(static_cast< int >(result));
52714 return resultobj;
52715 fail:
52716 return NULL;
52717 }
52718
52719
52720 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52721 PyObject *obj;
52722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52723 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52724 return SWIG_Py_Void();
52725 }
52726
52727 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52728 PyObject *resultobj = 0;
52729 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52730 wxIndividualLayoutConstraint *result = 0 ;
52731 void *argp1 = 0 ;
52732 int res1 = 0 ;
52733 PyObject *swig_obj[1] ;
52734
52735 if (!args) SWIG_fail;
52736 swig_obj[0] = args;
52737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52738 if (!SWIG_IsOK(res1)) {
52739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52740 }
52741 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52742 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52744 return resultobj;
52745 fail:
52746 return NULL;
52747 }
52748
52749
52750 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52751 PyObject *resultobj = 0;
52752 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52753 wxIndividualLayoutConstraint *result = 0 ;
52754 void *argp1 = 0 ;
52755 int res1 = 0 ;
52756 PyObject *swig_obj[1] ;
52757
52758 if (!args) SWIG_fail;
52759 swig_obj[0] = args;
52760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52761 if (!SWIG_IsOK(res1)) {
52762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52763 }
52764 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52765 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52767 return resultobj;
52768 fail:
52769 return NULL;
52770 }
52771
52772
52773 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52774 PyObject *resultobj = 0;
52775 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52776 wxIndividualLayoutConstraint *result = 0 ;
52777 void *argp1 = 0 ;
52778 int res1 = 0 ;
52779 PyObject *swig_obj[1] ;
52780
52781 if (!args) SWIG_fail;
52782 swig_obj[0] = args;
52783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52784 if (!SWIG_IsOK(res1)) {
52785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52786 }
52787 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52788 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52790 return resultobj;
52791 fail:
52792 return NULL;
52793 }
52794
52795
52796 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52797 PyObject *resultobj = 0;
52798 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52799 wxIndividualLayoutConstraint *result = 0 ;
52800 void *argp1 = 0 ;
52801 int res1 = 0 ;
52802 PyObject *swig_obj[1] ;
52803
52804 if (!args) SWIG_fail;
52805 swig_obj[0] = args;
52806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52807 if (!SWIG_IsOK(res1)) {
52808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52809 }
52810 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52811 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52813 return resultobj;
52814 fail:
52815 return NULL;
52816 }
52817
52818
52819 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52820 PyObject *resultobj = 0;
52821 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52822 wxIndividualLayoutConstraint *result = 0 ;
52823 void *argp1 = 0 ;
52824 int res1 = 0 ;
52825 PyObject *swig_obj[1] ;
52826
52827 if (!args) SWIG_fail;
52828 swig_obj[0] = args;
52829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52830 if (!SWIG_IsOK(res1)) {
52831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52832 }
52833 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52834 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52836 return resultobj;
52837 fail:
52838 return NULL;
52839 }
52840
52841
52842 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52843 PyObject *resultobj = 0;
52844 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52845 wxIndividualLayoutConstraint *result = 0 ;
52846 void *argp1 = 0 ;
52847 int res1 = 0 ;
52848 PyObject *swig_obj[1] ;
52849
52850 if (!args) SWIG_fail;
52851 swig_obj[0] = args;
52852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52853 if (!SWIG_IsOK(res1)) {
52854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52855 }
52856 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52857 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52859 return resultobj;
52860 fail:
52861 return NULL;
52862 }
52863
52864
52865 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52866 PyObject *resultobj = 0;
52867 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52868 wxIndividualLayoutConstraint *result = 0 ;
52869 void *argp1 = 0 ;
52870 int res1 = 0 ;
52871 PyObject *swig_obj[1] ;
52872
52873 if (!args) SWIG_fail;
52874 swig_obj[0] = args;
52875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52876 if (!SWIG_IsOK(res1)) {
52877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52878 }
52879 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52880 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52882 return resultobj;
52883 fail:
52884 return NULL;
52885 }
52886
52887
52888 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52889 PyObject *resultobj = 0;
52890 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52891 wxIndividualLayoutConstraint *result = 0 ;
52892 void *argp1 = 0 ;
52893 int res1 = 0 ;
52894 PyObject *swig_obj[1] ;
52895
52896 if (!args) SWIG_fail;
52897 swig_obj[0] = args;
52898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52899 if (!SWIG_IsOK(res1)) {
52900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52901 }
52902 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52903 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52905 return resultobj;
52906 fail:
52907 return NULL;
52908 }
52909
52910
52911 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52912 PyObject *resultobj = 0;
52913 wxLayoutConstraints *result = 0 ;
52914
52915 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52916 {
52917 PyThreadState* __tstate = wxPyBeginAllowThreads();
52918 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52919 wxPyEndAllowThreads(__tstate);
52920 if (PyErr_Occurred()) SWIG_fail;
52921 }
52922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52923 return resultobj;
52924 fail:
52925 return NULL;
52926 }
52927
52928
52929 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52930 PyObject *resultobj = 0;
52931 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52932 void *argp1 = 0 ;
52933 int res1 = 0 ;
52934 PyObject *swig_obj[1] ;
52935
52936 if (!args) SWIG_fail;
52937 swig_obj[0] = args;
52938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52939 if (!SWIG_IsOK(res1)) {
52940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52941 }
52942 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52943 {
52944 PyThreadState* __tstate = wxPyBeginAllowThreads();
52945 delete arg1;
52946
52947 wxPyEndAllowThreads(__tstate);
52948 if (PyErr_Occurred()) SWIG_fail;
52949 }
52950 resultobj = SWIG_Py_Void();
52951 return resultobj;
52952 fail:
52953 return NULL;
52954 }
52955
52956
52957 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52958 PyObject *resultobj = 0;
52959 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52960 wxWindow *arg2 = (wxWindow *) 0 ;
52961 int *arg3 = (int *) 0 ;
52962 bool result;
52963 void *argp1 = 0 ;
52964 int res1 = 0 ;
52965 void *argp2 = 0 ;
52966 int res2 = 0 ;
52967 int temp3 ;
52968 int res3 = SWIG_TMPOBJ ;
52969 PyObject * obj0 = 0 ;
52970 PyObject * obj1 = 0 ;
52971 char * kwnames[] = {
52972 (char *) "self",(char *) "win", NULL
52973 };
52974
52975 arg3 = &temp3;
52976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52978 if (!SWIG_IsOK(res1)) {
52979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52980 }
52981 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52983 if (!SWIG_IsOK(res2)) {
52984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52985 }
52986 arg2 = reinterpret_cast< wxWindow * >(argp2);
52987 {
52988 PyThreadState* __tstate = wxPyBeginAllowThreads();
52989 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52990 wxPyEndAllowThreads(__tstate);
52991 if (PyErr_Occurred()) SWIG_fail;
52992 }
52993 {
52994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52995 }
52996 if (SWIG_IsTmpObj(res3)) {
52997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52998 } else {
52999 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53001 }
53002 return resultobj;
53003 fail:
53004 return NULL;
53005 }
53006
53007
53008 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53009 PyObject *resultobj = 0;
53010 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53011 bool result;
53012 void *argp1 = 0 ;
53013 int res1 = 0 ;
53014 PyObject *swig_obj[1] ;
53015
53016 if (!args) SWIG_fail;
53017 swig_obj[0] = args;
53018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53019 if (!SWIG_IsOK(res1)) {
53020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53021 }
53022 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53023 {
53024 PyThreadState* __tstate = wxPyBeginAllowThreads();
53025 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53026 wxPyEndAllowThreads(__tstate);
53027 if (PyErr_Occurred()) SWIG_fail;
53028 }
53029 {
53030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53031 }
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53039 PyObject *obj;
53040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53041 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53042 return SWIG_Py_Void();
53043 }
53044
53045 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53046 return SWIG_Python_InitShadowInstance(args);
53047 }
53048
53049 static PyMethodDef SwigMethods[] = {
53050 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53051 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53052 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53053 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53054 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53055 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53056 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53057 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53058 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53060 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53067 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53071 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53072 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53073 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53075 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53076 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53077 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53078 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53079 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53080 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53081 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53083 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53089 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53090 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53091 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53092 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53093 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53094 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53095 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53097 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53105 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53106 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53107 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53112 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53113 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53115 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53117 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53119 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53121 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53123 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53125 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53126 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53128 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53130 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53131 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53132 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53133 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53153 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53154 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53155 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53156 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53157 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53158 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53159 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53160 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53162 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53163 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53164 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53169 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53170 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53171 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53172 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53179 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53183 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53186 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53187 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53188 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53189 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53191 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53192 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53193 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53195 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53196 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53197 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53198 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53203 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53204 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53205 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53206 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53207 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53208 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53211 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53212 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53213 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53215 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53216 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53218 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53219 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53220 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53221 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53222 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53223 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53224 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53225 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53226 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53227 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53228 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53233 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53239 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53240 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53241 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53242 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53244 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53247 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53249 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53252 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53253 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53254 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53257 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53258 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53259 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53263 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53264 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53265 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53269 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53274 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53275 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53276 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53277 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53278 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53279 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53280 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53287 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53288 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53290 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53291 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53292 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53298 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53299 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53301 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53302 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53303 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53304 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53305 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53306 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53307 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53308 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53310 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53311 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53312 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53313 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53314 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53315 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53316 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53317 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53319 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53328 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53340 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53341 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53356 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53357 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53358 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53359 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53362 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53363 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53364 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53366 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53368 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53370 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53373 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53374 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53375 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53376 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53378 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53395 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53396 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53402 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53403 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53405 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53406 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53407 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53408 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53409 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53410 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53411 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53412 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53413 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53414 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53415 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53417 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53418 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53420 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53421 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53422 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53423 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53424 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53426 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53427 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53428 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53429 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53430 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53431 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53432 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53433 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53434 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53435 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53436 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53437 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53439 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53440 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53441 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53442 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53445 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53449 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53453 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53454 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53455 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53456 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53458 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53459 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53461 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53463 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53465 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53467 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53468 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53469 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53471 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53472 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53474 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53475 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53476 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53478 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53479 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53480 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53482 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53484 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53485 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53486 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53488 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53490 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53491 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53493 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53494 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53495 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53497 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53498 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53499 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53500 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53501 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53503 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53504 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53507 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53508 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53510 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53511 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53514 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53515 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53517 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53523 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53524 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53525 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53526 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53527 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53528 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53529 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53530 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53531 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53532 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53533 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53534 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53535 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53536 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53537 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53538 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53539 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53540 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53541 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53542 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53543 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53544 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53545 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53546 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53548 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53549 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53550 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53551 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53552 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53553 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53554 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53555 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53556 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53557 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53558 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53559 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53560 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53561 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53562 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53563 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53564 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53565 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53566 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53567 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53568 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53569 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53570 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53571 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53572 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53573 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53574 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53575 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53576 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53577 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53578 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53579 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53581 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53582 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53584 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53585 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53586 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53587 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53589 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53590 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53591 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53592 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53593 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53594 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53595 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53596 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53597 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53599 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53600 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53601 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53602 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53603 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53604 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53605 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53606 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53607 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53608 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53609 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53610 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53611 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53612 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53613 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53614 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53615 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53616 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53617 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53618 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53619 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53620 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53621 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53622 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53623 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53624 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53625 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53626 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53628 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53629 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53632 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53633 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53634 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53635 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53636 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53637 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53639 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53640 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53643 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53644 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53646 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53647 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53649 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53650 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53652 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53653 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53654 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53656 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53658 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53659 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53661 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53662 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53663 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53665 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53666 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53667 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53669 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53670 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53672 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53673 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53674 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53675 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53676 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53679 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53681 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53683 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53684 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53685 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53688 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53689 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53690 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53692 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53693 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53694 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53696 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53697 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53698 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53699 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53700 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53701 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53703 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53704 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53705 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53706 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53707 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53708 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53709 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53710 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53716 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53718 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53720 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53721 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53722 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53723 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53724 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53725 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53727 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53728 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53729 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53731 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53732 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53733 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53734 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53735 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53738 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53739 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53740 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53743 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53744 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53745 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53746 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53747 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53749 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53751 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53754 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53756 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53757 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53759 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53760 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53761 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53763 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53764 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53765 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53767 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53769 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53770 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53771 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53773 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53775 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53777 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53778 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53780 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53781 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53783 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53785 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53786 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53787 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53789 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53791 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53792 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53793 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53795 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53797 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53798 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53799 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53800 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53802 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53804 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53806 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53808 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53809 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53811 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53812 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53813 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53814 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53815 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53816 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53817 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53818 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53820 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53822 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53824 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53826 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53828 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53830 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53831 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53832 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53833 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53834 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53835 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53841 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53842 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53843 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53844 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53845 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53846 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53847 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53848 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53850 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53852 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53853 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53855 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53856 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53857 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53858 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53860 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53861 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53862 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53863 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53865 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53866 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53868 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53869 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53870 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53872 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53874 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53875 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53876 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53877 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53878 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53880 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53881 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53882 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53883 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53885 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53886 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53887 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53888 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53889 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53890 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53891 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53892 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53893 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53894 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53896 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53899 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53900 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53901 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53903 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53905 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53907 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53909 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53910 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53920 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53921 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53925 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53926 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53927 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53928 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53929 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53930 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53931 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53932 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53933 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53934 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53935 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53936 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53937 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53938 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53939 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53941 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53942 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53945 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53946 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53951 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53952 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53955 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53956 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53957 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53958 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53961 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53962 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53963 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53965 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53967 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53968 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53969 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53971 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53973 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53975 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53978 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53979 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53980 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53981 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53982 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53983 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53987 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53988 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53989 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53990 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53997 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54003 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54004 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54005 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54006 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54007 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54009 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54019 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54020 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54021 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54022 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54025 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54026 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54027 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54028 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54030 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54031 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54035 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54041 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54042 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54043 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54044 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54046 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54047 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54049 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54052 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54054 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54055 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54056 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54065 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54069 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54070 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54072 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54082 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54083 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54084 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54085 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54089 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54092 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54094 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54097 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54098 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54099 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54100 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54103 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54105 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54106 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54107 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54108 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54110 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54111 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54116 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54117 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54118 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54120 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54121 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54122 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54124 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54126 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54127 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54128 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54130 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54131 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54134 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54142 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54149 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54157 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54160 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54161 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54174 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54176 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54178 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54179 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54181 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54183 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54184 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54186 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54187 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54188 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54192 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54211 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54212 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54214 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54215 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54217 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54218 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54219 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54221 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54222 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54225 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54226 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54228 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54229 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54231 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54234 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54235 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54237 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54239 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54241 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54242 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54244 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54245 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54248 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54250 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54252 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54254 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54257 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54259 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54260 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54261 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54263 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54264 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54265 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54267 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54269 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54270 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54272 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54273 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54274 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54275 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54279 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54283 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54284 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54286 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54290 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54292 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54294 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54295 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54296 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54297 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54301 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54302 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54303 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54304 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54306 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54307 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54312 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54313 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54314 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54315 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54316 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54318 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54320 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54322 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54323 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54325 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54327 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54330 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54331 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54332 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54334 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54335 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54336 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54350 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54351 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54352 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54353 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54354 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54355 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54361 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54362 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54366 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54367 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54369 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54370 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54372 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54374 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54375 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54377 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54378 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54379 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54385 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54386 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54387 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54388 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54389 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54390 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54397 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54399 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54400 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54401 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54402 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54403 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54404 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54406 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54410 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54411 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54412 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54413 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54414 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54415 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54416 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54418 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54419 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54420 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54426 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54427 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54428 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54430 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54431 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54432 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54438 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54439 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54440 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54441 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54442 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54446 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54447 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54452 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54453 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54455 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54456 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54461 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54463 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54464 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54465 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54466 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54467 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54472 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54473 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54482 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54483 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54484 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54485 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54488 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54490 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54491 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54492 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54493 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54495 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54500 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54501 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54502 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54503 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54504 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54505 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54506 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54507 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54508 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54509 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54510 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54512 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54513 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54514 { NULL, NULL, 0, NULL }
54515 };
54516
54517
54518 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54519
54520 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54521 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54522 }
54523 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54524 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54525 }
54526 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54527 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54528 }
54529 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54530 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54531 }
54532 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54533 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54534 }
54535 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54536 return (void *)((wxSizer *) ((wxGridSizer *) x));
54537 }
54538 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54539 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54540 }
54541 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54542 return (void *)((wxSizer *) ((wxPySizer *) x));
54543 }
54544 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54545 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54546 }
54547 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54548 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54549 }
54550 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54551 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54552 }
54553 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54554 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54555 }
54556 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54557 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54558 }
54559 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54560 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54561 }
54562 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54563 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54564 }
54565 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54566 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54567 }
54568 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54569 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54570 }
54571 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54572 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54573 }
54574 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54575 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54576 }
54577 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54578 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54579 }
54580 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54581 return (void *)((wxEvent *) ((wxPyEvent *) x));
54582 }
54583 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54584 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54585 }
54586 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54587 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54588 }
54589 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54590 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54591 }
54592 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54593 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54594 }
54595 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54596 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54597 }
54598 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54599 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54600 }
54601 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54602 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54603 }
54604 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54605 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54606 }
54607 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54608 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54609 }
54610 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54611 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54612 }
54613 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54614 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54615 }
54616 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54617 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54618 }
54619 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54620 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54621 }
54622 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54623 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54624 }
54625 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54626 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54627 }
54628 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54629 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54630 }
54631 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54632 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54633 }
54634 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54635 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54636 }
54637 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54638 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54639 }
54640 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54641 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54642 }
54643 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54644 return (void *)((wxEvent *) ((wxShowEvent *) x));
54645 }
54646 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54647 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54648 }
54649 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54650 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54651 }
54652 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54653 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54654 }
54655 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54656 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54657 }
54658 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54659 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54660 }
54661 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54662 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54663 }
54664 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54665 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54666 }
54667 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54668 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54669 }
54670 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54671 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54672 }
54673 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54674 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54675 }
54676 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54677 return (void *)((wxControl *) ((wxControlWithItems *) x));
54678 }
54679 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54680 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54681 }
54682 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54683 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54684 }
54685 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54686 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54687 }
54688 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54689 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54690 }
54691 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54692 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54693 }
54694 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54695 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54696 }
54697 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54698 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54699 }
54700 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54701 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54702 }
54703 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54704 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54705 }
54706 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54707 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54708 }
54709 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54710 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54711 }
54712 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54713 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54714 }
54715 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54716 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54717 }
54718 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54719 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54720 }
54721 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54722 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54723 }
54724 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54725 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54726 }
54727 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54728 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54729 }
54730 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54731 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54732 }
54733 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54734 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54735 }
54736 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54737 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54738 }
54739 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54740 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54741 }
54742 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54743 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54744 }
54745 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54746 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54747 }
54748 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54749 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54750 }
54751 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54752 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54753 }
54754 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54755 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54756 }
54757 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54758 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54759 }
54760 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54761 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54762 }
54763 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54764 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54765 }
54766 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54767 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54768 }
54769 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54770 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54771 }
54772 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54773 return (void *)((wxObject *) ((wxSizerItem *) x));
54774 }
54775 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54776 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54777 }
54778 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54779 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54780 }
54781 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54782 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54783 }
54784 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54785 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54786 }
54787 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54788 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54789 }
54790 static void *_p_wxSizerTo_p_wxObject(void *x) {
54791 return (void *)((wxObject *) ((wxSizer *) x));
54792 }
54793 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54794 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54795 }
54796 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54797 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54798 }
54799 static void *_p_wxEventTo_p_wxObject(void *x) {
54800 return (void *)((wxObject *) ((wxEvent *) x));
54801 }
54802 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54803 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54804 }
54805 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54806 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54807 }
54808 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54809 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54810 }
54811 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54812 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54813 }
54814 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54815 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54816 }
54817 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54818 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54819 }
54820 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54821 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54822 }
54823 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54824 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54825 }
54826 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54827 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54828 }
54829 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54830 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54831 }
54832 static void *_p_wxControlTo_p_wxObject(void *x) {
54833 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54834 }
54835 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54836 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54837 }
54838 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54839 return (void *)((wxObject *) ((wxFSFile *) x));
54840 }
54841 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54842 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54843 }
54844 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54845 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54846 }
54847 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54848 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54849 }
54850 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54851 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54852 }
54853 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54854 return (void *)((wxObject *) ((wxMenuItem *) x));
54855 }
54856 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54857 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54858 }
54859 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54860 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54861 }
54862 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54863 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54864 }
54865 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54866 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54867 }
54868 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54869 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54870 }
54871 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54872 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54873 }
54874 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54875 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54876 }
54877 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54878 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54879 }
54880 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54881 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54882 }
54883 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54884 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54885 }
54886 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54887 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54888 }
54889 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54890 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54891 }
54892 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54893 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54894 }
54895 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54896 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54897 }
54898 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54899 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54900 }
54901 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54902 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54903 }
54904 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54905 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54906 }
54907 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54908 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54909 }
54910 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54911 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54912 }
54913 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54914 return (void *)((wxObject *) ((wxImageHandler *) x));
54915 }
54916 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54917 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54918 }
54919 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54920 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54921 }
54922 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54923 return (void *)((wxObject *) ((wxEvtHandler *) x));
54924 }
54925 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54926 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54927 }
54928 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54929 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54930 }
54931 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54932 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54933 }
54934 static void *_p_wxImageTo_p_wxObject(void *x) {
54935 return (void *)((wxObject *) ((wxImage *) x));
54936 }
54937 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54938 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54939 }
54940 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54941 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54942 }
54943 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54944 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54945 }
54946 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54947 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54948 }
54949 static void *_p_wxWindowTo_p_wxObject(void *x) {
54950 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54951 }
54952 static void *_p_wxMenuTo_p_wxObject(void *x) {
54953 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54954 }
54955 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54956 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54957 }
54958 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54959 return (void *)((wxObject *) ((wxFileSystem *) x));
54960 }
54961 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54962 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54963 }
54964 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54965 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54966 }
54967 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54968 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54969 }
54970 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54971 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54972 }
54973 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54974 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54975 }
54976 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54977 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54978 }
54979 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54980 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54981 }
54982 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54983 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54984 }
54985 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54986 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54987 }
54988 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54989 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54990 }
54991 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54992 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54993 }
54994 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54995 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54996 }
54997 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54998 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54999 }
55000 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55001 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55002 }
55003 static void *_p_wxControlTo_p_wxWindow(void *x) {
55004 return (void *)((wxWindow *) ((wxControl *) x));
55005 }
55006 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55007 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55008 }
55009 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55010 return (void *)((wxWindow *) ((wxMenuBar *) x));
55011 }
55012 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55013 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55014 }
55015 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55016 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55017 }
55018 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55019 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55020 }
55021 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55022 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55023 }
55024 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55025 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55026 }
55027 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55028 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55029 }
55030 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55031 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55032 }
55033 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55034 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55035 }
55036 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55037 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55038 }
55039 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55040 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55041 }
55042 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55043 return (void *)((wxValidator *) ((wxPyValidator *) x));
55044 }
55045 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55046 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55047 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};
55048 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55049 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55050 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55051 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55052 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55053 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55054 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55055 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55056 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55057 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55167 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55168 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55169 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55170 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55171 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55172 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55173 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55174 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55175 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55176 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55177
55178 static swig_type_info *swig_type_initial[] = {
55179 &_swigt__p_buffer,
55180 &_swigt__p_char,
55181 &_swigt__p_form_ops_t,
55182 &_swigt__p_int,
55183 &_swigt__p_long,
55184 &_swigt__p_unsigned_char,
55185 &_swigt__p_unsigned_int,
55186 &_swigt__p_unsigned_long,
55187 &_swigt__p_wxANIHandler,
55188 &_swigt__p_wxAcceleratorEntry,
55189 &_swigt__p_wxAcceleratorTable,
55190 &_swigt__p_wxActivateEvent,
55191 &_swigt__p_wxAppTraits,
55192 &_swigt__p_wxArrayString,
55193 &_swigt__p_wxBMPHandler,
55194 &_swigt__p_wxBitmap,
55195 &_swigt__p_wxBoxSizer,
55196 &_swigt__p_wxButton,
55197 &_swigt__p_wxCURHandler,
55198 &_swigt__p_wxCaret,
55199 &_swigt__p_wxChildFocusEvent,
55200 &_swigt__p_wxClipboardTextEvent,
55201 &_swigt__p_wxCloseEvent,
55202 &_swigt__p_wxColour,
55203 &_swigt__p_wxCommandEvent,
55204 &_swigt__p_wxContextMenuEvent,
55205 &_swigt__p_wxControl,
55206 &_swigt__p_wxControlWithItems,
55207 &_swigt__p_wxCursor,
55208 &_swigt__p_wxDC,
55209 &_swigt__p_wxDateEvent,
55210 &_swigt__p_wxDateTime,
55211 &_swigt__p_wxDisplayChangedEvent,
55212 &_swigt__p_wxDropFilesEvent,
55213 &_swigt__p_wxDuplexMode,
55214 &_swigt__p_wxEraseEvent,
55215 &_swigt__p_wxEvent,
55216 &_swigt__p_wxEventLoop,
55217 &_swigt__p_wxEventLoopActivator,
55218 &_swigt__p_wxEvtHandler,
55219 &_swigt__p_wxFSFile,
55220 &_swigt__p_wxFileSystem,
55221 &_swigt__p_wxFileSystemHandler,
55222 &_swigt__p_wxFlexGridSizer,
55223 &_swigt__p_wxFocusEvent,
55224 &_swigt__p_wxFont,
55225 &_swigt__p_wxFrame,
55226 &_swigt__p_wxGBPosition,
55227 &_swigt__p_wxGBSizerItem,
55228 &_swigt__p_wxGBSpan,
55229 &_swigt__p_wxGIFHandler,
55230 &_swigt__p_wxGridBagSizer,
55231 &_swigt__p_wxGridSizer,
55232 &_swigt__p_wxHelpEvent__Origin,
55233 &_swigt__p_wxICOHandler,
55234 &_swigt__p_wxIconizeEvent,
55235 &_swigt__p_wxIdleEvent,
55236 &_swigt__p_wxImage,
55237 &_swigt__p_wxImageHandler,
55238 &_swigt__p_wxImageHistogram,
55239 &_swigt__p_wxImage_HSVValue,
55240 &_swigt__p_wxImage_RGBValue,
55241 &_swigt__p_wxIndividualLayoutConstraint,
55242 &_swigt__p_wxInitDialogEvent,
55243 &_swigt__p_wxInputStream,
55244 &_swigt__p_wxInternetFSHandler,
55245 &_swigt__p_wxItemContainer,
55246 &_swigt__p_wxJPEGHandler,
55247 &_swigt__p_wxKeyEvent,
55248 &_swigt__p_wxLayoutConstraints,
55249 &_swigt__p_wxMaximizeEvent,
55250 &_swigt__p_wxMemoryFSHandler,
55251 &_swigt__p_wxMenu,
55252 &_swigt__p_wxMenuBar,
55253 &_swigt__p_wxMenuBarBase,
55254 &_swigt__p_wxMenuEvent,
55255 &_swigt__p_wxMenuItem,
55256 &_swigt__p_wxMouseCaptureChangedEvent,
55257 &_swigt__p_wxMouseCaptureLostEvent,
55258 &_swigt__p_wxMouseEvent,
55259 &_swigt__p_wxMoveEvent,
55260 &_swigt__p_wxNavigationKeyEvent,
55261 &_swigt__p_wxNcPaintEvent,
55262 &_swigt__p_wxNotifyEvent,
55263 &_swigt__p_wxObject,
55264 &_swigt__p_wxOutputStream,
55265 &_swigt__p_wxPCXHandler,
55266 &_swigt__p_wxPNGHandler,
55267 &_swigt__p_wxPNMHandler,
55268 &_swigt__p_wxPaintEvent,
55269 &_swigt__p_wxPaletteChangedEvent,
55270 &_swigt__p_wxPaperSize,
55271 &_swigt__p_wxPoint,
55272 &_swigt__p_wxPoint2D,
55273 &_swigt__p_wxPropagateOnce,
55274 &_swigt__p_wxPropagationDisabler,
55275 &_swigt__p_wxPyApp,
55276 &_swigt__p_wxPyCommandEvent,
55277 &_swigt__p_wxPyDropTarget,
55278 &_swigt__p_wxPyEvent,
55279 &_swigt__p_wxPyFileSystemHandler,
55280 &_swigt__p_wxPyImageHandler,
55281 &_swigt__p_wxPyInputStream,
55282 &_swigt__p_wxPySizer,
55283 &_swigt__p_wxPyValidator,
55284 &_swigt__p_wxQuantize,
55285 &_swigt__p_wxQueryNewPaletteEvent,
55286 &_swigt__p_wxRealPoint,
55287 &_swigt__p_wxRect,
55288 &_swigt__p_wxRegion,
55289 &_swigt__p_wxScrollEvent,
55290 &_swigt__p_wxScrollWinEvent,
55291 &_swigt__p_wxSetCursorEvent,
55292 &_swigt__p_wxShowEvent,
55293 &_swigt__p_wxSize,
55294 &_swigt__p_wxSizeEvent,
55295 &_swigt__p_wxSizer,
55296 &_swigt__p_wxSizerItem,
55297 &_swigt__p_wxStaticBox,
55298 &_swigt__p_wxStaticBoxSizer,
55299 &_swigt__p_wxStdDialogButtonSizer,
55300 &_swigt__p_wxSysColourChangedEvent,
55301 &_swigt__p_wxTIFFHandler,
55302 &_swigt__p_wxToolTip,
55303 &_swigt__p_wxUpdateUIEvent,
55304 &_swigt__p_wxValidator,
55305 &_swigt__p_wxVisualAttributes,
55306 &_swigt__p_wxWindow,
55307 &_swigt__p_wxWindowCreateEvent,
55308 &_swigt__p_wxWindowDestroyEvent,
55309 &_swigt__p_wxXPMHandler,
55310 &_swigt__p_wxZipFSHandler,
55311 };
55312
55313 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55314 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55315 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55316 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55317 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55318 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55319 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55320 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55321 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55322 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55323 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55327 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}};
55328 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55329 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}};
55330 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55331 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}};
55332 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55336 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55337 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}};
55338 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55339 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}};
55340 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55342 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55343 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55345 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55346 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55347 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55348 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55352 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}};
55353 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55355 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}};
55356 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}};
55357 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55358 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55361 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55362 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55364 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55365 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}};
55366 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55367 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}};
55368 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55369 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55370 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55371 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}};
55372 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55374 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55379 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}};
55380 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55387 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55388 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55419 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55420 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55421 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55428 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55429 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}};
55430 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}};
55431 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55435 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55436 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55437 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55438 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}};
55439 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55440 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}};
55441 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55442 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55443 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55444 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55445
55446 static swig_cast_info *swig_cast_initial[] = {
55447 _swigc__p_buffer,
55448 _swigc__p_char,
55449 _swigc__p_form_ops_t,
55450 _swigc__p_int,
55451 _swigc__p_long,
55452 _swigc__p_unsigned_char,
55453 _swigc__p_unsigned_int,
55454 _swigc__p_unsigned_long,
55455 _swigc__p_wxANIHandler,
55456 _swigc__p_wxAcceleratorEntry,
55457 _swigc__p_wxAcceleratorTable,
55458 _swigc__p_wxActivateEvent,
55459 _swigc__p_wxAppTraits,
55460 _swigc__p_wxArrayString,
55461 _swigc__p_wxBMPHandler,
55462 _swigc__p_wxBitmap,
55463 _swigc__p_wxBoxSizer,
55464 _swigc__p_wxButton,
55465 _swigc__p_wxCURHandler,
55466 _swigc__p_wxCaret,
55467 _swigc__p_wxChildFocusEvent,
55468 _swigc__p_wxClipboardTextEvent,
55469 _swigc__p_wxCloseEvent,
55470 _swigc__p_wxColour,
55471 _swigc__p_wxCommandEvent,
55472 _swigc__p_wxContextMenuEvent,
55473 _swigc__p_wxControl,
55474 _swigc__p_wxControlWithItems,
55475 _swigc__p_wxCursor,
55476 _swigc__p_wxDC,
55477 _swigc__p_wxDateEvent,
55478 _swigc__p_wxDateTime,
55479 _swigc__p_wxDisplayChangedEvent,
55480 _swigc__p_wxDropFilesEvent,
55481 _swigc__p_wxDuplexMode,
55482 _swigc__p_wxEraseEvent,
55483 _swigc__p_wxEvent,
55484 _swigc__p_wxEventLoop,
55485 _swigc__p_wxEventLoopActivator,
55486 _swigc__p_wxEvtHandler,
55487 _swigc__p_wxFSFile,
55488 _swigc__p_wxFileSystem,
55489 _swigc__p_wxFileSystemHandler,
55490 _swigc__p_wxFlexGridSizer,
55491 _swigc__p_wxFocusEvent,
55492 _swigc__p_wxFont,
55493 _swigc__p_wxFrame,
55494 _swigc__p_wxGBPosition,
55495 _swigc__p_wxGBSizerItem,
55496 _swigc__p_wxGBSpan,
55497 _swigc__p_wxGIFHandler,
55498 _swigc__p_wxGridBagSizer,
55499 _swigc__p_wxGridSizer,
55500 _swigc__p_wxHelpEvent__Origin,
55501 _swigc__p_wxICOHandler,
55502 _swigc__p_wxIconizeEvent,
55503 _swigc__p_wxIdleEvent,
55504 _swigc__p_wxImage,
55505 _swigc__p_wxImageHandler,
55506 _swigc__p_wxImageHistogram,
55507 _swigc__p_wxImage_HSVValue,
55508 _swigc__p_wxImage_RGBValue,
55509 _swigc__p_wxIndividualLayoutConstraint,
55510 _swigc__p_wxInitDialogEvent,
55511 _swigc__p_wxInputStream,
55512 _swigc__p_wxInternetFSHandler,
55513 _swigc__p_wxItemContainer,
55514 _swigc__p_wxJPEGHandler,
55515 _swigc__p_wxKeyEvent,
55516 _swigc__p_wxLayoutConstraints,
55517 _swigc__p_wxMaximizeEvent,
55518 _swigc__p_wxMemoryFSHandler,
55519 _swigc__p_wxMenu,
55520 _swigc__p_wxMenuBar,
55521 _swigc__p_wxMenuBarBase,
55522 _swigc__p_wxMenuEvent,
55523 _swigc__p_wxMenuItem,
55524 _swigc__p_wxMouseCaptureChangedEvent,
55525 _swigc__p_wxMouseCaptureLostEvent,
55526 _swigc__p_wxMouseEvent,
55527 _swigc__p_wxMoveEvent,
55528 _swigc__p_wxNavigationKeyEvent,
55529 _swigc__p_wxNcPaintEvent,
55530 _swigc__p_wxNotifyEvent,
55531 _swigc__p_wxObject,
55532 _swigc__p_wxOutputStream,
55533 _swigc__p_wxPCXHandler,
55534 _swigc__p_wxPNGHandler,
55535 _swigc__p_wxPNMHandler,
55536 _swigc__p_wxPaintEvent,
55537 _swigc__p_wxPaletteChangedEvent,
55538 _swigc__p_wxPaperSize,
55539 _swigc__p_wxPoint,
55540 _swigc__p_wxPoint2D,
55541 _swigc__p_wxPropagateOnce,
55542 _swigc__p_wxPropagationDisabler,
55543 _swigc__p_wxPyApp,
55544 _swigc__p_wxPyCommandEvent,
55545 _swigc__p_wxPyDropTarget,
55546 _swigc__p_wxPyEvent,
55547 _swigc__p_wxPyFileSystemHandler,
55548 _swigc__p_wxPyImageHandler,
55549 _swigc__p_wxPyInputStream,
55550 _swigc__p_wxPySizer,
55551 _swigc__p_wxPyValidator,
55552 _swigc__p_wxQuantize,
55553 _swigc__p_wxQueryNewPaletteEvent,
55554 _swigc__p_wxRealPoint,
55555 _swigc__p_wxRect,
55556 _swigc__p_wxRegion,
55557 _swigc__p_wxScrollEvent,
55558 _swigc__p_wxScrollWinEvent,
55559 _swigc__p_wxSetCursorEvent,
55560 _swigc__p_wxShowEvent,
55561 _swigc__p_wxSize,
55562 _swigc__p_wxSizeEvent,
55563 _swigc__p_wxSizer,
55564 _swigc__p_wxSizerItem,
55565 _swigc__p_wxStaticBox,
55566 _swigc__p_wxStaticBoxSizer,
55567 _swigc__p_wxStdDialogButtonSizer,
55568 _swigc__p_wxSysColourChangedEvent,
55569 _swigc__p_wxTIFFHandler,
55570 _swigc__p_wxToolTip,
55571 _swigc__p_wxUpdateUIEvent,
55572 _swigc__p_wxValidator,
55573 _swigc__p_wxVisualAttributes,
55574 _swigc__p_wxWindow,
55575 _swigc__p_wxWindowCreateEvent,
55576 _swigc__p_wxWindowDestroyEvent,
55577 _swigc__p_wxXPMHandler,
55578 _swigc__p_wxZipFSHandler,
55579 };
55580
55581
55582 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55583
55584 static swig_const_info swig_const_table[] = {
55585 {0, 0, 0, 0.0, 0, 0}};
55586
55587 #ifdef __cplusplus
55588 }
55589 #endif
55590 /* -----------------------------------------------------------------------------
55591 * Type initialization:
55592 * This problem is tough by the requirement that no dynamic
55593 * memory is used. Also, since swig_type_info structures store pointers to
55594 * swig_cast_info structures and swig_cast_info structures store pointers back
55595 * to swig_type_info structures, we need some lookup code at initialization.
55596 * The idea is that swig generates all the structures that are needed.
55597 * The runtime then collects these partially filled structures.
55598 * The SWIG_InitializeModule function takes these initial arrays out of
55599 * swig_module, and does all the lookup, filling in the swig_module.types
55600 * array with the correct data and linking the correct swig_cast_info
55601 * structures together.
55602 *
55603 * The generated swig_type_info structures are assigned staticly to an initial
55604 * array. We just loop though that array, and handle each type individually.
55605 * First we lookup if this type has been already loaded, and if so, use the
55606 * loaded structure instead of the generated one. Then we have to fill in the
55607 * cast linked list. The cast data is initially stored in something like a
55608 * two-dimensional array. Each row corresponds to a type (there are the same
55609 * number of rows as there are in the swig_type_initial array). Each entry in
55610 * a column is one of the swig_cast_info structures for that type.
55611 * The cast_initial array is actually an array of arrays, because each row has
55612 * a variable number of columns. So to actually build the cast linked list,
55613 * we find the array of casts associated with the type, and loop through it
55614 * adding the casts to the list. The one last trick we need to do is making
55615 * sure the type pointer in the swig_cast_info struct is correct.
55616 *
55617 * First off, we lookup the cast->type name to see if it is already loaded.
55618 * There are three cases to handle:
55619 * 1) If the cast->type has already been loaded AND the type we are adding
55620 * casting info to has not been loaded (it is in this module), THEN we
55621 * replace the cast->type pointer with the type pointer that has already
55622 * been loaded.
55623 * 2) If BOTH types (the one we are adding casting info to, and the
55624 * cast->type) are loaded, THEN the cast info has already been loaded by
55625 * the previous module so we just ignore it.
55626 * 3) Finally, if cast->type has not already been loaded, then we add that
55627 * swig_cast_info to the linked list (because the cast->type) pointer will
55628 * be correct.
55629 * ----------------------------------------------------------------------------- */
55630
55631 #ifdef __cplusplus
55632 extern "C" {
55633 #if 0
55634 } /* c-mode */
55635 #endif
55636 #endif
55637
55638 #if 0
55639 #define SWIGRUNTIME_DEBUG
55640 #endif
55641
55642 SWIGRUNTIME void
55643 SWIG_InitializeModule(void *clientdata) {
55644 size_t i;
55645 swig_module_info *module_head;
55646 static int init_run = 0;
55647
55648 clientdata = clientdata;
55649
55650 if (init_run) return;
55651 init_run = 1;
55652
55653 /* Initialize the swig_module */
55654 swig_module.type_initial = swig_type_initial;
55655 swig_module.cast_initial = swig_cast_initial;
55656
55657 /* Try and load any already created modules */
55658 module_head = SWIG_GetModule(clientdata);
55659 if (module_head) {
55660 swig_module.next = module_head->next;
55661 module_head->next = &swig_module;
55662 } else {
55663 /* This is the first module loaded */
55664 swig_module.next = &swig_module;
55665 SWIG_SetModule(clientdata, &swig_module);
55666 }
55667
55668 /* Now work on filling in swig_module.types */
55669 #ifdef SWIGRUNTIME_DEBUG
55670 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55671 #endif
55672 for (i = 0; i < swig_module.size; ++i) {
55673 swig_type_info *type = 0;
55674 swig_type_info *ret;
55675 swig_cast_info *cast;
55676
55677 #ifdef SWIGRUNTIME_DEBUG
55678 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55679 #endif
55680
55681 /* if there is another module already loaded */
55682 if (swig_module.next != &swig_module) {
55683 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55684 }
55685 if (type) {
55686 /* Overwrite clientdata field */
55687 #ifdef SWIGRUNTIME_DEBUG
55688 printf("SWIG_InitializeModule: found type %s\n", type->name);
55689 #endif
55690 if (swig_module.type_initial[i]->clientdata) {
55691 type->clientdata = swig_module.type_initial[i]->clientdata;
55692 #ifdef SWIGRUNTIME_DEBUG
55693 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55694 #endif
55695 }
55696 } else {
55697 type = swig_module.type_initial[i];
55698 }
55699
55700 /* Insert casting types */
55701 cast = swig_module.cast_initial[i];
55702 while (cast->type) {
55703 /* Don't need to add information already in the list */
55704 ret = 0;
55705 #ifdef SWIGRUNTIME_DEBUG
55706 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55707 #endif
55708 if (swig_module.next != &swig_module) {
55709 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55710 #ifdef SWIGRUNTIME_DEBUG
55711 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55712 #endif
55713 }
55714 if (ret) {
55715 if (type == swig_module.type_initial[i]) {
55716 #ifdef SWIGRUNTIME_DEBUG
55717 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55718 #endif
55719 cast->type = ret;
55720 ret = 0;
55721 } else {
55722 /* Check for casting already in the list */
55723 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55724 #ifdef SWIGRUNTIME_DEBUG
55725 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55726 #endif
55727 if (!ocast) ret = 0;
55728 }
55729 }
55730
55731 if (!ret) {
55732 #ifdef SWIGRUNTIME_DEBUG
55733 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55734 #endif
55735 if (type->cast) {
55736 type->cast->prev = cast;
55737 cast->next = type->cast;
55738 }
55739 type->cast = cast;
55740 }
55741 cast++;
55742 }
55743 /* Set entry in modules->types array equal to the type */
55744 swig_module.types[i] = type;
55745 }
55746 swig_module.types[i] = 0;
55747
55748 #ifdef SWIGRUNTIME_DEBUG
55749 printf("**** SWIG_InitializeModule: Cast List ******\n");
55750 for (i = 0; i < swig_module.size; ++i) {
55751 int j = 0;
55752 swig_cast_info *cast = swig_module.cast_initial[i];
55753 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55754 while (cast->type) {
55755 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55756 cast++;
55757 ++j;
55758 }
55759 printf("---- Total casts: %d\n",j);
55760 }
55761 printf("**** SWIG_InitializeModule: Cast List ******\n");
55762 #endif
55763 }
55764
55765 /* This function will propagate the clientdata field of type to
55766 * any new swig_type_info structures that have been added into the list
55767 * of equivalent types. It is like calling
55768 * SWIG_TypeClientData(type, clientdata) a second time.
55769 */
55770 SWIGRUNTIME void
55771 SWIG_PropagateClientData(void) {
55772 size_t i;
55773 swig_cast_info *equiv;
55774 static int init_run = 0;
55775
55776 if (init_run) return;
55777 init_run = 1;
55778
55779 for (i = 0; i < swig_module.size; i++) {
55780 if (swig_module.types[i]->clientdata) {
55781 equiv = swig_module.types[i]->cast;
55782 while (equiv) {
55783 if (!equiv->converter) {
55784 if (equiv->type && !equiv->type->clientdata)
55785 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55786 }
55787 equiv = equiv->next;
55788 }
55789 }
55790 }
55791 }
55792
55793 #ifdef __cplusplus
55794 #if 0
55795 {
55796 /* c-mode */
55797 #endif
55798 }
55799 #endif
55800
55801
55802
55803 #ifdef __cplusplus
55804 extern "C" {
55805 #endif
55806
55807 /* Python-specific SWIG API */
55808 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55809 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55810 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55811
55812 /* -----------------------------------------------------------------------------
55813 * global variable support code.
55814 * ----------------------------------------------------------------------------- */
55815
55816 typedef struct swig_globalvar {
55817 char *name; /* Name of global variable */
55818 PyObject *(*get_attr)(void); /* Return the current value */
55819 int (*set_attr)(PyObject *); /* Set the value */
55820 struct swig_globalvar *next;
55821 } swig_globalvar;
55822
55823 typedef struct swig_varlinkobject {
55824 PyObject_HEAD
55825 swig_globalvar *vars;
55826 } swig_varlinkobject;
55827
55828 SWIGINTERN PyObject *
55829 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55830 return PyString_FromString("<Swig global variables>");
55831 }
55832
55833 SWIGINTERN PyObject *
55834 swig_varlink_str(swig_varlinkobject *v) {
55835 PyObject *str = PyString_FromString("(");
55836 swig_globalvar *var;
55837 for (var = v->vars; var; var=var->next) {
55838 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55839 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55840 }
55841 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55842 return str;
55843 }
55844
55845 SWIGINTERN int
55846 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55847 PyObject *str = swig_varlink_str(v);
55848 fprintf(fp,"Swig global variables ");
55849 fprintf(fp,"%s\n", PyString_AsString(str));
55850 Py_DECREF(str);
55851 return 0;
55852 }
55853
55854 SWIGINTERN void
55855 swig_varlink_dealloc(swig_varlinkobject *v) {
55856 swig_globalvar *var = v->vars;
55857 while (var) {
55858 swig_globalvar *n = var->next;
55859 free(var->name);
55860 free(var);
55861 var = n;
55862 }
55863 }
55864
55865 SWIGINTERN PyObject *
55866 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55867 PyObject *res = NULL;
55868 swig_globalvar *var = v->vars;
55869 while (var) {
55870 if (strcmp(var->name,n) == 0) {
55871 res = (*var->get_attr)();
55872 break;
55873 }
55874 var = var->next;
55875 }
55876 if (res == NULL && !PyErr_Occurred()) {
55877 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55878 }
55879 return res;
55880 }
55881
55882 SWIGINTERN int
55883 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55884 int res = 1;
55885 swig_globalvar *var = v->vars;
55886 while (var) {
55887 if (strcmp(var->name,n) == 0) {
55888 res = (*var->set_attr)(p);
55889 break;
55890 }
55891 var = var->next;
55892 }
55893 if (res == 1 && !PyErr_Occurred()) {
55894 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55895 }
55896 return res;
55897 }
55898
55899 SWIGINTERN PyTypeObject*
55900 swig_varlink_type(void) {
55901 static char varlink__doc__[] = "Swig var link object";
55902 static PyTypeObject varlink_type;
55903 static int type_init = 0;
55904 if (!type_init) {
55905 const PyTypeObject tmp
55906 = {
55907 PyObject_HEAD_INIT(NULL)
55908 0, /* Number of items in variable part (ob_size) */
55909 (char *)"swigvarlink", /* Type name (tp_name) */
55910 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55911 0, /* Itemsize (tp_itemsize) */
55912 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55913 (printfunc) swig_varlink_print, /* Print (tp_print) */
55914 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55915 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55916 0, /* tp_compare */
55917 (reprfunc) swig_varlink_repr, /* tp_repr */
55918 0, /* tp_as_number */
55919 0, /* tp_as_sequence */
55920 0, /* tp_as_mapping */
55921 0, /* tp_hash */
55922 0, /* tp_call */
55923 (reprfunc)swig_varlink_str, /* tp_str */
55924 0, /* tp_getattro */
55925 0, /* tp_setattro */
55926 0, /* tp_as_buffer */
55927 0, /* tp_flags */
55928 varlink__doc__, /* tp_doc */
55929 0, /* tp_traverse */
55930 0, /* tp_clear */
55931 0, /* tp_richcompare */
55932 0, /* tp_weaklistoffset */
55933 #if PY_VERSION_HEX >= 0x02020000
55934 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55935 #endif
55936 #if PY_VERSION_HEX >= 0x02030000
55937 0, /* tp_del */
55938 #endif
55939 #ifdef COUNT_ALLOCS
55940 0,0,0,0 /* tp_alloc -> tp_next */
55941 #endif
55942 };
55943 varlink_type = tmp;
55944 varlink_type.ob_type = &PyType_Type;
55945 type_init = 1;
55946 }
55947 return &varlink_type;
55948 }
55949
55950 /* Create a variable linking object for use later */
55951 SWIGINTERN PyObject *
55952 SWIG_Python_newvarlink(void) {
55953 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55954 if (result) {
55955 result->vars = 0;
55956 }
55957 return ((PyObject*) result);
55958 }
55959
55960 SWIGINTERN void
55961 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55962 swig_varlinkobject *v = (swig_varlinkobject *) p;
55963 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55964 if (gv) {
55965 size_t size = strlen(name)+1;
55966 gv->name = (char *)malloc(size);
55967 if (gv->name) {
55968 strncpy(gv->name,name,size);
55969 gv->get_attr = get_attr;
55970 gv->set_attr = set_attr;
55971 gv->next = v->vars;
55972 }
55973 }
55974 v->vars = gv;
55975 }
55976
55977 SWIGINTERN PyObject *
55978 SWIG_globals() {
55979 static PyObject *_SWIG_globals = 0;
55980 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55981 return _SWIG_globals;
55982 }
55983
55984 /* -----------------------------------------------------------------------------
55985 * constants/methods manipulation
55986 * ----------------------------------------------------------------------------- */
55987
55988 /* Install Constants */
55989 SWIGINTERN void
55990 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55991 PyObject *obj = 0;
55992 size_t i;
55993 for (i = 0; constants[i].type; ++i) {
55994 switch(constants[i].type) {
55995 case SWIG_PY_POINTER:
55996 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55997 break;
55998 case SWIG_PY_BINARY:
55999 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56000 break;
56001 default:
56002 obj = 0;
56003 break;
56004 }
56005 if (obj) {
56006 PyDict_SetItemString(d, constants[i].name, obj);
56007 Py_DECREF(obj);
56008 }
56009 }
56010 }
56011
56012 /* -----------------------------------------------------------------------------*/
56013 /* Fix SwigMethods to carry the callback ptrs when needed */
56014 /* -----------------------------------------------------------------------------*/
56015
56016 SWIGINTERN void
56017 SWIG_Python_FixMethods(PyMethodDef *methods,
56018 swig_const_info *const_table,
56019 swig_type_info **types,
56020 swig_type_info **types_initial) {
56021 size_t i;
56022 for (i = 0; methods[i].ml_name; ++i) {
56023 const char *c = methods[i].ml_doc;
56024 if (c && (c = strstr(c, "swig_ptr: "))) {
56025 int j;
56026 swig_const_info *ci = 0;
56027 const char *name = c + 10;
56028 for (j = 0; const_table[j].type; ++j) {
56029 if (strncmp(const_table[j].name, name,
56030 strlen(const_table[j].name)) == 0) {
56031 ci = &(const_table[j]);
56032 break;
56033 }
56034 }
56035 if (ci) {
56036 size_t shift = (ci->ptype) - types;
56037 swig_type_info *ty = types_initial[shift];
56038 size_t ldoc = (c - methods[i].ml_doc);
56039 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56040 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56041 if (ndoc) {
56042 char *buff = ndoc;
56043 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56044 if (ptr) {
56045 strncpy(buff, methods[i].ml_doc, ldoc);
56046 buff += ldoc;
56047 strncpy(buff, "swig_ptr: ", 10);
56048 buff += 10;
56049 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56050 methods[i].ml_doc = ndoc;
56051 }
56052 }
56053 }
56054 }
56055 }
56056 }
56057
56058 #ifdef __cplusplus
56059 }
56060 #endif
56061
56062 /* -----------------------------------------------------------------------------*
56063 * Partial Init method
56064 * -----------------------------------------------------------------------------*/
56065
56066 #ifdef __cplusplus
56067 extern "C"
56068 #endif
56069 SWIGEXPORT void SWIG_init(void) {
56070 PyObject *m, *d;
56071
56072 /* Fix SwigMethods to carry the callback ptrs when needed */
56073 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56074
56075 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56076 d = PyModule_GetDict(m);
56077
56078 SWIG_InitializeModule(0);
56079 SWIG_InstallConstants(d,swig_const_table);
56080
56081
56082
56083 #ifndef wxPyUSE_EXPORT
56084 // Make our API structure a CObject so other modules can import it
56085 // from this module.
56086 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56087 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56088 Py_XDECREF(cobj);
56089 #endif
56090
56091 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56092 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56093 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56094 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56095 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56096 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56097 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56098 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56099 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56100 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56101 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56102 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56103 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56104 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56105 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56106 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56107 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56108 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56109 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56110 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56111 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56112 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56113 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56114 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56115 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56116 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56117 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56118 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56119 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56120 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56121 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56122 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56123 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56124 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56125 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56126 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56127 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56128 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56129 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56130 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56131 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56132 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56133 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56134 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56135 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56136 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56137 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56138 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56139 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56140 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56141 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56142 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56143 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56144 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56145 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56146 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56147 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56148 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56149 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56150 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56151 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56152 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56153 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56154 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56155 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56156 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56157 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56158 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56159 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56160 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56161 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56162 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56163 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56164 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56165 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56166 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56167 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56168 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56169 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56170 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56171 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56172 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56173 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56174 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56175 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56176 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56177 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56178 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56179 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56180 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56181 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56182 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56183 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56184 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56185 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56186 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56187 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56188 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56189 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56190 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56191 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56192 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56193 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56194 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56195 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56196 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56197 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56198 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56199 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56200 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56201 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56202 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56203 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56204 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56205 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56206 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56207 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56208 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56209 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56210 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56211 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56212 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56213 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56214 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56215 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56216 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56217 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56218 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56219 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56220 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56221 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56222 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56223 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56224 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56225 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56226 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56227 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56228 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56229 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56230 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56231 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56232 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56233 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56234 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56235 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56236 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56237 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56238 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56239 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56240 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56241 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56242 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56243 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56244 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56245 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56246 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56247 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56248 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56249 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56250 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56251 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56252 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56253 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56254 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56255 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56256 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56257 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56258 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56259 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56260 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56261 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56262 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56263 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56264 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56265 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56266 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56267 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56268 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56269 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56270 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56271 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56272 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56273 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56274 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56275 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56276 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56277 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56278 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56279 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56280 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56281 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56282 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56283 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56284 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56285 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56286 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56287 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56288 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56289 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56290 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56291 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56292 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56293 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56294 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56295 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56296 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56297 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56298 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56299 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56300 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56301 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56302 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56303 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56304 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56305 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56306 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56307 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56308 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56309 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56310 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56311 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56312 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56313 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56314 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56315 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56316 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56317 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56318 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56319 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56320 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56321 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56322 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56323 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56324 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56325 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56326 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56327 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56328 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56329 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56330 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56331 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56332 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56333 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56334 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56335 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56336 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56337 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56338 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56339 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56340 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56341 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56342 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56343 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56344 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56345 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56346 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56347 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56348 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56349 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56350 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56351 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56352 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56353 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56354 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56355 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56356 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56357 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56358 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56359 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56360 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56361 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56362 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56363 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56364 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56365 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56366 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56367 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56368 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56369 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56370 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56371 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56372 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56373 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56374 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56375 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56376 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56377 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56378 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56379 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56380 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56381 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56382 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56383 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56384 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56385 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56386 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56387 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56388 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56389 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56390 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56391 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56392 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56393 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56394 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56395 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56396 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56397 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56398 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56399 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56400 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56401 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56402 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56403 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56404 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56405 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56406 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56407 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56408 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56409 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56410 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56411 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56412 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56413 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56414 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56415 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56416 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56417 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56418 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56419 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56420 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56421 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56422 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56423 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56424 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56425 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56426 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56427 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56428 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56429 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56430 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56431 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56432 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56433 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56434 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56435 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56436 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56437 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56438 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56439 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56440 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56441 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56442 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56443 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56444 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56445 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56446 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56447 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56448 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56449 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56450 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56451 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56452 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56453 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56454 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56455 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56456 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56457 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56458 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56459 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56460 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56461 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56462 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56463 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56464 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56465 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56466 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56467 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56468 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56469 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56470 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56471 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56472 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56473 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56474 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56475 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56476 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56477 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56478 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56479 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56480 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56481 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56482 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56483 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56484 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56485 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56486 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56487 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56488 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56489 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56490 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56491 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56492 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56493 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56494 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56495 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56496 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56497 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56498 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56499 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56508 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56509 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56510 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56511 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56512 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56513 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56514 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56515 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56516 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56517 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56518 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56519 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56520 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56521 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56522 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56523 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56524 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56525 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56526 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56527 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56528 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56529 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56530 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56532 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56533 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56534 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56535 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56536 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56537 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56538 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56539 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56540 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56541 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56542 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56543 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56544 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56545 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56546 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56547 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56548 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56549 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56550 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56551 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56552 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56553 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56554 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56555 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56556 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56557 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56558 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56559 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56560 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56561 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56562 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56563 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56564 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56565 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56566 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56567 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56568 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56569 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56570 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56571 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56572 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56573 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56574 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56575 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56576 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56577 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56578 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56579 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56580 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56581 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56582 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56583 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56584 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56585 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56586 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56587 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56588 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56589 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56590 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56591 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56592 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56593 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56594 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56595 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56596 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56597 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56598 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56599 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56600 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56601 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56602 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56603 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56604 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56605 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56606 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56607 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56608 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56609 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56610 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56611 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56612 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56613 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56614 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56615 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56616 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56617 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56618 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56619 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56620 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56621 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56622 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56623 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56624 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56625 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56626 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56627 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56628 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56629 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56630 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56631 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56632 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56633 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56634 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56635 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56636 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56637 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56638 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56639 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56640 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56641 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56642 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56643 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56644 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56649 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56650 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56651 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56652 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56653 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56654 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56655 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56656 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56657 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56658 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56659 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56660 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56661 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56662 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56663 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56664 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56665 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56666 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56667 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56668 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56669 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56670 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56671 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56672 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56673 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56674 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56675 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56676 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56677 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56678 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56679 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56680 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56681 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56682 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56683 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56684 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56685 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56686 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56687 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56688 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56689 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56690 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56691 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56692 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56693 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56694 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56695 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56696 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56697 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56698 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56699 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56700 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56701 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56702 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56703 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56704 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56705 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56707 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56708 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56709 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56710 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56711 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56712 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56713 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56714 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56715 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56716 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56717 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56718 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56719 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56720 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56721 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56722 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56723 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56724 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56725 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56726 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56727 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56728 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56729 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56730 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56731 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56732 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56733 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56734 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56735 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56736 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56737 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56738 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56739 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56740 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56741 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56742 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56743 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56744 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56745 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56746 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56747 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56748 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56749 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56750 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56751 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56752 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56753 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56754 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56755 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56756 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56757
56758 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56759
56760
56761 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56762
56763 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56764 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56765 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56766 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56767 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56768 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56769 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56770 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56771 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56772 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56773 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56774 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56775 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56776 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56777 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56778 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56779 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56780 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56781 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56782 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56783 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56784 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56785 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56786 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56787 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56788 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56789 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56790 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56791 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56792 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56793 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56794 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56795 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56796 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56797 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56798 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56799 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56800 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56801 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56802 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56803 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56804 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56805 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56806 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56807 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56808 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56809 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56810 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56811 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56812 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56813 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56814 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56815 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56816 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56817 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56818 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56819 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56820 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56821 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56822 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56823 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56824 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56825 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56826 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56827 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56828 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56829 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56830 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56831 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56832 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56833 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56834 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56835 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56836 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56837 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56838 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56839 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56840 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56841 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56842 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56843 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56844 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56845 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56846 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56847 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56848 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56849 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56850 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56851 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56852 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56853 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56854 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56855 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56856 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56857 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56858 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56859 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56860 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56861 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56862 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56863 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56864 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56865 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56866 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56867 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56868 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56869 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56870 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56871 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56872 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56873 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56874 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56875 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56876 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56877 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56878 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56879 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56880 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56881 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56882 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56883 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56884 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56885 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56886 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56887 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56888 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56889 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56890 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56891 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56892 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56893 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56894 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56895 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56896 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56897 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56898 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56899 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56900 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56901 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56902 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56903 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56904 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56905 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56906 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56907 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56908 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56909 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56910 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56911 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56912 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56913 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56914 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56915 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56916 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56917 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56918 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56919 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56920 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56921 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56922 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56923 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56924 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56925 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56926 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56927 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56928 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56929 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56930 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56931 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56932 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56933 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56934 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56935 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56936 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56937 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56938 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56939 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56940 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56941 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56942 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56943 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56944 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56945 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56946 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56947 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56948 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56949 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56950 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56951 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56952 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56953 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56954 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56955 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56956 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56957 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56958 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56959 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56960 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56961 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56962 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56963 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56964 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56965 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56966 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56967 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56968 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56969 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56970
56971 // Initialize threading, some globals and such
56972 __wxPyPreStart(d);
56973
56974
56975 // Although these are defined in __version__ they need to be here too so
56976 // that an assert can be done to ensure that the wxPython and the wxWindows
56977 // versions match.
56978 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56979 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56980 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56981
56982 }
56983
wxWidgets (Impactor)