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


b167a64fb72c7b231b544c944473c8c9d67b39ff
[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_wxMouseEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMoveEvent swig_types[79]
2546 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNcPaintEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNotifyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxObject swig_types[83]
2550 #define SWIGTYPE_p_wxOutputStream swig_types[84]
2551 #define SWIGTYPE_p_wxPCXHandler swig_types[85]
2552 #define SWIGTYPE_p_wxPNGHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNMHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPaintEvent swig_types[88]
2555 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaperSize swig_types[90]
2557 #define SWIGTYPE_p_wxPoint swig_types[91]
2558 #define SWIGTYPE_p_wxPoint2D swig_types[92]
2559 #define SWIGTYPE_p_wxPropagateOnce swig_types[93]
2560 #define SWIGTYPE_p_wxPropagationDisabler swig_types[94]
2561 #define SWIGTYPE_p_wxPyApp swig_types[95]
2562 #define SWIGTYPE_p_wxPyCommandEvent swig_types[96]
2563 #define SWIGTYPE_p_wxPyDropTarget swig_types[97]
2564 #define SWIGTYPE_p_wxPyEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[99]
2566 #define SWIGTYPE_p_wxPyImageHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyInputStream swig_types[101]
2568 #define SWIGTYPE_p_wxPySizer swig_types[102]
2569 #define SWIGTYPE_p_wxPyValidator swig_types[103]
2570 #define SWIGTYPE_p_wxQuantize swig_types[104]
2571 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[105]
2572 #define SWIGTYPE_p_wxRealPoint swig_types[106]
2573 #define SWIGTYPE_p_wxRect swig_types[107]
2574 #define SWIGTYPE_p_wxRegion swig_types[108]
2575 #define SWIGTYPE_p_wxScrollEvent swig_types[109]
2576 #define SWIGTYPE_p_wxScrollWinEvent swig_types[110]
2577 #define SWIGTYPE_p_wxSetCursorEvent swig_types[111]
2578 #define SWIGTYPE_p_wxShowEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSize swig_types[113]
2580 #define SWIGTYPE_p_wxSizeEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSizer swig_types[115]
2582 #define SWIGTYPE_p_wxSizerItem swig_types[116]
2583 #define SWIGTYPE_p_wxStaticBox swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[120]
2587 #define SWIGTYPE_p_wxTIFFHandler swig_types[121]
2588 #define SWIGTYPE_p_wxToolTip swig_types[122]
2589 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[123]
2590 #define SWIGTYPE_p_wxValidator swig_types[124]
2591 #define SWIGTYPE_p_wxVisualAttributes swig_types[125]
2592 #define SWIGTYPE_p_wxWindow swig_types[126]
2593 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[127]
2594 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[128]
2595 #define SWIGTYPE_p_wxXPMHandler swig_types[129]
2596 #define SWIGTYPE_p_wxZipFSHandler swig_types[130]
2597 static swig_type_info *swig_types[132];
2598 static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0};
2599 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2600 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2601
2602 /* -------- TYPES TABLE (END) -------- */
2603
2604 #if (PY_VERSION_HEX <= 0x02000000)
2605 # if !defined(SWIG_PYTHON_CLASSIC)
2606 # error "This python version requires to use swig with the '-classic' option"
2607 # endif
2608 #endif
2609 #if (PY_VERSION_HEX <= 0x02020000)
2610 # error "This python version requires to use swig with the '-nomodern' option"
2611 #endif
2612 #if (PY_VERSION_HEX <= 0x02020000)
2613 # error "This python version requires to use swig with the '-nomodernargs' option"
2614 #endif
2615 #ifndef METH_O
2616 # error "This python version requires to use swig with the '-nofastunpack' option"
2617 #endif
2618
2619 /*-----------------------------------------------
2620 @(target):= _core_.so
2621 ------------------------------------------------*/
2622 #define SWIG_init init_core_
2623
2624 #define SWIG_name "_core_"
2625
2626 #define SWIGVERSION 0x010329
2627
2628
2629 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2630 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2631
2632
2633 #include <stdexcept>
2634
2635
2636 namespace swig {
2637 class PyObject_ptr {
2638 protected:
2639 PyObject *_obj;
2640
2641 public:
2642 PyObject_ptr() :_obj(0)
2643 {
2644 }
2645
2646 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2647 {
2648 Py_XINCREF(_obj);
2649 }
2650
2651 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2652 {
2653 if (initial_ref) Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr & operator=(const PyObject_ptr& item)
2657 {
2658 Py_XINCREF(item._obj);
2659 Py_XDECREF(_obj);
2660 _obj = item._obj;
2661 return *this;
2662 }
2663
2664 ~PyObject_ptr()
2665 {
2666 Py_XDECREF(_obj);
2667 }
2668
2669 operator PyObject *() const
2670 {
2671 return _obj;
2672 }
2673
2674 PyObject *operator->() const
2675 {
2676 return _obj;
2677 }
2678 };
2679 }
2680
2681
2682 namespace swig {
2683 struct PyObject_var : PyObject_ptr {
2684 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2685
2686 PyObject_var & operator = (PyObject* obj)
2687 {
2688 Py_XDECREF(_obj);
2689 _obj = obj;
2690 return *this;
2691 }
2692 };
2693 }
2694
2695
2696 #include "wx/wxPython/wxPython_int.h"
2697 #include "wx/wxPython/pyclasses.h"
2698 #include "wx/wxPython/twoitem.h"
2699
2700
2701 #ifndef wxPyUSE_EXPORT
2702 // Helper functions for dealing with SWIG objects and such. These are
2703 // located here so they know about the SWIG types and functions declared
2704 // in the wrapper code.
2705
2706 #include <wx/hashmap.h>
2707 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2708
2709
2710 // Maintains a hashmap of className to swig_type_info pointers. Given the
2711 // name of a class either looks up the type info in the cache, or scans the
2712 // SWIG tables for it.
2713 extern PyObject* wxPyPtrTypeMap;
2714 static
2715 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2716
2717 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2718
2719 if (typeInfoCache == NULL)
2720 typeInfoCache = new wxPyTypeInfoHashMap;
2721
2722 wxString name(className);
2723 swig_type_info* swigType = (*typeInfoCache)[name];
2724
2725 if (! swigType) {
2726 // it wasn't in the cache, so look it up from SWIG
2727 name.Append(wxT(" *"));
2728 swigType = SWIG_TypeQuery(name.mb_str());
2729
2730 // if it still wasn't found, try looking for a mapped name
2731 if (!swigType) {
2732 PyObject* item;
2733 name = className;
2734
2735 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2736 (char*)(const char*)name.mbc_str())) != NULL) {
2737 name = wxString(PyString_AsString(item), *wxConvCurrent);
2738 name.Append(wxT(" *"));
2739 swigType = SWIG_TypeQuery(name.mb_str());
2740 }
2741 }
2742 if (swigType) {
2743 // and add it to the map if found
2744 (*typeInfoCache)[className] = swigType;
2745 }
2746 }
2747 return swigType;
2748 }
2749
2750
2751 // Check if a class name is a type known to SWIG
2752 bool wxPyCheckSwigType(const wxChar* className) {
2753
2754 swig_type_info* swigType = wxPyFindSwigType(className);
2755 return swigType != NULL;
2756 }
2757
2758
2759 // Given a pointer to a C++ object and a class name, construct a Python proxy
2760 // object for it.
2761 PyObject* wxPyConstructObject(void* ptr,
2762 const wxChar* className,
2763 int setThisOwn) {
2764
2765 swig_type_info* swigType = wxPyFindSwigType(className);
2766 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2767
2768 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2769 }
2770
2771
2772 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2773 // Ensures that the proxy object is of the specified (or derived) type. If
2774 // not able to perform the conversion then a Python exception is set and the
2775 // error should be handled properly in the caller. Returns True on success.
2776 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2777 const wxChar* className) {
2778
2779 swig_type_info* swigType = wxPyFindSwigType(className);
2780 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2781
2782 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2783 }
2784
2785
2786
2787 // Make a SWIGified pointer object suitable for a .this attribute
2788 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2789
2790 PyObject* robj = NULL;
2791
2792 swig_type_info* swigType = wxPyFindSwigType(className);
2793 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2794
2795 robj = PySwigObject_New(ptr, swigType, 0);
2796 return robj;
2797 }
2798
2799
2800 // Python's PyInstance_Check does not return True for instances of new-style
2801 // classes. This should get close enough for both new and old classes but I
2802 // should re-evaluate the need for doing instance checks...
2803 bool wxPyInstance_Check(PyObject* obj) {
2804 return PyObject_HasAttrString(obj, "__class__") != 0;
2805 }
2806
2807
2808 // This one checks if the object is an instance of a SWIG proxy class (it has
2809 // a .this attribute, and the .this attribute is a PySwigObject.)
2810 bool wxPySwigInstance_Check(PyObject* obj) {
2811 static PyObject* this_str = NULL;
2812 if (this_str == NULL)
2813 this_str = PyString_FromString("this");
2814
2815 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2816 if (this_attr) {
2817 bool retval = (PySwigObject_Check(this_attr) != 0);
2818 Py_DECREF(this_attr);
2819 return retval;
2820 }
2821
2822 PyErr_Clear();
2823 return false;
2824 }
2825
2826
2827 // Export a C API in a struct. Other modules will be able to load this from
2828 // the wx._core_ module and will then have safe access to these functions,
2829 // even if they are located in another shared library.
2830 static wxPyCoreAPI API = {
2831
2832 wxPyCheckSwigType,
2833 wxPyConstructObject,
2834 wxPyConvertSwigPtr,
2835 wxPyMakeSwigPtr,
2836
2837 wxPyBeginAllowThreads,
2838 wxPyEndAllowThreads,
2839 wxPyBeginBlockThreads,
2840 wxPyEndBlockThreads,
2841
2842 wxPy_ConvertList,
2843
2844 wxString_in_helper,
2845 Py2wxString,
2846 wx2PyString,
2847
2848 byte_LIST_helper,
2849 int_LIST_helper,
2850 long_LIST_helper,
2851 string_LIST_helper,
2852 wxPoint_LIST_helper,
2853 wxBitmap_LIST_helper,
2854 wxString_LIST_helper,
2855 wxAcceleratorEntry_LIST_helper,
2856
2857 wxSize_helper,
2858 wxPoint_helper,
2859 wxRealPoint_helper,
2860 wxRect_helper,
2861 wxColour_helper,
2862 wxPoint2D_helper,
2863
2864 wxPySimple_typecheck,
2865 wxColour_typecheck,
2866
2867 wxPyCBH_setCallbackInfo,
2868 wxPyCBH_findCallback,
2869 wxPyCBH_callCallback,
2870 wxPyCBH_callCallbackObj,
2871 wxPyCBH_delete,
2872
2873 wxPyMake_wxObject,
2874 wxPyMake_wxSizer,
2875 wxPyPtrTypeMap_Add,
2876 wxPy2int_seq_helper,
2877 wxPy4int_seq_helper,
2878 wxArrayString2PyList_helper,
2879 wxArrayInt2PyList_helper,
2880
2881 wxPyClientData_dtor,
2882 wxPyUserData_dtor,
2883 wxPyOORClientData_dtor,
2884
2885 wxPyCBInputStream_create,
2886 wxPyCBInputStream_copy,
2887
2888 wxPyInstance_Check,
2889 wxPySwigInstance_Check,
2890
2891 wxPyCheckForApp
2892
2893 };
2894
2895 #endif
2896
2897
2898 #if !WXWIN_COMPATIBILITY_2_4
2899 #define wxHIDE_READONLY 0
2900 #endif
2901
2902
2903 #define SWIG_From_long PyInt_FromLong
2904
2905
2906 SWIGINTERNINLINE PyObject *
2907 SWIG_From_int (int value)
2908 {
2909 return SWIG_From_long (value);
2910 }
2911
2912 static const wxString wxPyEmptyString(wxEmptyString);
2913 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2914 return self->GetClassInfo()->GetClassName();
2915 }
2916 SWIGINTERN void wxObject_Destroy(wxObject *self){
2917 delete self;
2918 }
2919
2920 #ifndef __WXMAC__
2921 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2922 #endif
2923
2924
2925 #include <limits.h>
2926 #ifndef LLONG_MIN
2927 # define LLONG_MIN LONG_LONG_MIN
2928 #endif
2929 #ifndef LLONG_MAX
2930 # define LLONG_MAX LONG_LONG_MAX
2931 #endif
2932 #ifndef ULLONG_MAX
2933 # define ULLONG_MAX ULONG_LONG_MAX
2934 #endif
2935
2936
2937 SWIGINTERN int
2938 SWIG_AsVal_long (PyObject* obj, long* val)
2939 {
2940 if (PyNumber_Check(obj)) {
2941 if (val) *val = PyInt_AsLong(obj);
2942 return SWIG_OK;
2943 }
2944 return SWIG_TypeError;
2945 }
2946
2947
2948 SWIGINTERN int
2949 SWIG_AsVal_int (PyObject * obj, int *val)
2950 {
2951 long v;
2952 int res = SWIG_AsVal_long (obj, &v);
2953 if (SWIG_IsOK(res)) {
2954 if ((v < INT_MIN || v > INT_MAX)) {
2955 return SWIG_OverflowError;
2956 } else {
2957 if (val) *val = static_cast< int >(v);
2958 }
2959 }
2960 return res;
2961 }
2962
2963 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2964 wxSize temp, *obj = &temp;
2965 if ( other == Py_None ) return false;
2966 if ( ! wxSize_helper(other, &obj) ) {
2967 PyErr_Clear();
2968 return false;
2969 }
2970 return self->operator==(*obj);
2971 }
2972 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return true;
2975 if ( ! wxSize_helper(other, &obj)) {
2976 PyErr_Clear();
2977 return true;
2978 }
2979 return self->operator!=(*obj);
2980 }
2981 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2983 PyObject* tup = PyTuple_New(2);
2984 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2985 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2986 wxPyEndBlockThreads(blocked);
2987 return tup;
2988 }
2989
2990 SWIGINTERN int
2991 SWIG_AsVal_double (PyObject *obj, double* val)
2992 {
2993 if (PyNumber_Check(obj)) {
2994 if (val) *val = PyFloat_AsDouble(obj);
2995 return SWIG_OK;
2996 }
2997 return SWIG_TypeError;
2998 }
2999
3000
3001 #define SWIG_From_double PyFloat_FromDouble
3002
3003 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3004 wxRealPoint temp, *obj = &temp;
3005 if ( other == Py_None ) return false;
3006 if ( ! wxRealPoint_helper(other, &obj) ) {
3007 PyErr_Clear();
3008 return false;
3009 }
3010 return self->operator==(*obj);
3011 }
3012 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3013 wxRealPoint temp, *obj = &temp;
3014 if ( other == Py_None ) return true;
3015 if ( ! wxRealPoint_helper(other, &obj)) {
3016 PyErr_Clear();
3017 return true;
3018 }
3019 return self->operator!=(*obj);
3020 }
3021 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3022 self->x = x;
3023 self->y = y;
3024 }
3025 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 PyObject* tup = PyTuple_New(2);
3028 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3029 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3030 wxPyEndBlockThreads(blocked);
3031 return tup;
3032 }
3033 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3034 wxPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return false;
3036 if ( ! wxPoint_helper(other, &obj) ) {
3037 PyErr_Clear();
3038 return false;
3039 }
3040 return self->operator==(*obj);
3041 }
3042 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3043 wxPoint temp, *obj = &temp;
3044 if ( other == Py_None ) return true;
3045 if ( ! wxPoint_helper(other, &obj)) {
3046 PyErr_Clear();
3047 return true;
3048 }
3049 return self->operator!=(*obj);
3050 }
3051 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3052 self->x = x;
3053 self->y = y;
3054 }
3055 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3057 PyObject* tup = PyTuple_New(2);
3058 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3059 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3060 wxPyEndBlockThreads(blocked);
3061 return tup;
3062 }
3063 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3064 wxRect temp, *obj = &temp;
3065 if ( other == Py_None ) return false;
3066 if ( ! wxRect_helper(other, &obj) ) {
3067 PyErr_Clear();
3068 return false;
3069 }
3070 return self->operator==(*obj);
3071 }
3072 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3073 wxRect temp, *obj = &temp;
3074 if ( other == Py_None ) return true;
3075 if ( ! wxRect_helper(other, &obj)) {
3076 PyErr_Clear();
3077 return true;
3078 }
3079 return self->operator!=(*obj);
3080 }
3081 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3082 self->x = x;
3083 self->y = y;
3084 self->width = width;
3085 self->height = height;
3086 }
3087 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3089 PyObject* tup = PyTuple_New(4);
3090 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3091 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3092 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3093 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3094 wxPyEndBlockThreads(blocked);
3095 return tup;
3096 }
3097
3098 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3099 wxRegion reg1(*r1);
3100 wxRegion reg2(*r2);
3101 wxRect dest(0,0,0,0);
3102 PyObject* obj;
3103
3104 reg1.Intersect(reg2);
3105 dest = reg1.GetBox();
3106
3107 if (dest != wxRect(0,0,0,0)) {
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 wxRect* newRect = new wxRect(dest);
3110 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3111 wxPyEndBlockThreads(blocked);
3112 return obj;
3113 }
3114 Py_INCREF(Py_None);
3115 return Py_None;
3116 }
3117
3118 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3119 wxPoint2D temp, *obj = &temp;
3120 if ( other == Py_None ) return false;
3121 if ( ! wxPoint2D_helper(other, &obj) ) {
3122 PyErr_Clear();
3123 return false;
3124 }
3125 return self->operator==(*obj);
3126 }
3127 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3128 wxPoint2D temp, *obj = &temp;
3129 if ( other == Py_None ) return true;
3130 if ( ! wxPoint2D_helper(other, &obj)) {
3131 PyErr_Clear();
3132 return true;
3133 }
3134 return self->operator!=(*obj);
3135 }
3136 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3137 self->m_x = x;
3138 self->m_y = y;
3139 }
3140 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3142 PyObject* tup = PyTuple_New(2);
3143 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3144 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3145 wxPyEndBlockThreads(blocked);
3146 return tup;
3147 }
3148
3149 #include "wx/wxPython/pyistream.h"
3150
3151 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3152 wxInputStream* wxis = wxPyCBInputStream::create(p);
3153 if (wxis)
3154 return new wxPyInputStream(wxis);
3155 else
3156 return NULL;
3157 }
3158
3159 SWIGINTERN swig_type_info*
3160 SWIG_pchar_descriptor()
3161 {
3162 static int init = 0;
3163 static swig_type_info* info = 0;
3164 if (!init) {
3165 info = SWIG_TypeQuery("_p_char");
3166 init = 1;
3167 }
3168 return info;
3169 }
3170
3171
3172 SWIGINTERNINLINE PyObject *
3173 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3174 {
3175 if (carray) {
3176 if (size > INT_MAX) {
3177 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3178 return pchar_descriptor ?
3179 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3180 } else {
3181 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3182 }
3183 } else {
3184 return SWIG_Py_Void();
3185 }
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject *
3190 SWIG_From_char (char c)
3191 {
3192 return SWIG_FromCharPtrAndSize(&c,1);
3193 }
3194
3195
3196 SWIGINTERNINLINE PyObject*
3197 SWIG_From_unsigned_SS_long (unsigned long value)
3198 {
3199 return (value > LONG_MAX) ?
3200 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3201 }
3202
3203
3204 SWIGINTERNINLINE PyObject *
3205 SWIG_From_size_t (size_t value)
3206 {
3207 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3208 }
3209
3210
3211 SWIGINTERN int
3212 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3213 {
3214 if (PyString_Check(obj)) {
3215 char *cstr; Py_ssize_t len;
3216 PyString_AsStringAndSize(obj, &cstr, &len);
3217 if (cptr) {
3218 if (alloc) {
3219 /*
3220 In python the user should not be able to modify the inner
3221 string representation. To warranty that, if you define
3222 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3223 buffer is always returned.
3224
3225 The default behavior is just to return the pointer value,
3226 so, be careful.
3227 */
3228 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3229 if (*alloc != SWIG_OLDOBJ)
3230 #else
3231 if (*alloc == SWIG_NEWOBJ)
3232 #endif
3233 {
3234 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3235 *alloc = SWIG_NEWOBJ;
3236 }
3237 else {
3238 *cptr = cstr;
3239 *alloc = SWIG_OLDOBJ;
3240 }
3241 } else {
3242 *cptr = PyString_AsString(obj);
3243 }
3244 }
3245 if (psize) *psize = len + 1;
3246 return SWIG_OK;
3247 } else {
3248 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3249 if (pchar_descriptor) {
3250 void* vptr = 0;
3251 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3252 if (cptr) *cptr = (char *) vptr;
3253 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3254 if (alloc) *alloc = SWIG_OLDOBJ;
3255 return SWIG_OK;
3256 }
3257 }
3258 }
3259 return SWIG_TypeError;
3260 }
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3265 {
3266 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3267 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3268 if (SWIG_IsOK(res)) {
3269 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3270 if (csize <= size) {
3271 if (val) {
3272 if (csize) memcpy(val, cptr, csize*sizeof(char));
3273 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3274 }
3275 if (alloc == SWIG_NEWOBJ) {
3276 delete[] cptr;
3277 res = SWIG_DelNewMask(res);
3278 }
3279 return res;
3280 }
3281 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3282 }
3283 return SWIG_TypeError;
3284 }
3285
3286
3287 SWIGINTERN int
3288 SWIG_AsVal_char (PyObject * obj, char *val)
3289 {
3290 int res = SWIG_AsCharArray(obj, val, 1);
3291 if (!SWIG_IsOK(res)) {
3292 long v;
3293 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3294 if (SWIG_IsOK(res)) {
3295 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3296 if (val) *val = static_cast< char >(v);
3297 } else {
3298 res = SWIG_OverflowError;
3299 }
3300 }
3301 }
3302 return res;
3303 }
3304
3305 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3306 // We use only strings for the streams, not unicode
3307 PyObject* str = PyObject_Str(obj);
3308 if (! str) {
3309 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3310 return;
3311 }
3312 self->Write(PyString_AS_STRING(str),
3313 PyString_GET_SIZE(str));
3314 Py_DECREF(str);
3315 }
3316
3317 #include "wx/wxPython/pyistream.h"
3318
3319
3320 class wxPyFileSystemHandler : public wxFileSystemHandler
3321 {
3322 public:
3323 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3324
3325 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3326 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3327 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3328 DEC_PYCALLBACK_STRING__pure(FindNext);
3329
3330 wxString GetProtocol(const wxString& location) {
3331 return wxFileSystemHandler::GetProtocol(location);
3332 }
3333
3334 wxString GetLeftLocation(const wxString& location) {
3335 return wxFileSystemHandler::GetLeftLocation(location);
3336 }
3337
3338 wxString GetAnchor(const wxString& location) {
3339 return wxFileSystemHandler::GetAnchor(location);
3340 }
3341
3342 wxString GetRightLocation(const wxString& location) {
3343 return wxFileSystemHandler::GetRightLocation(location);
3344 }
3345
3346 wxString GetMimeTypeFromExt(const wxString& location) {
3347 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3348 }
3349
3350 PYPRIVATE;
3351 };
3352
3353
3354 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3355 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3356 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3357 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3358
3359
3360 SWIGINTERN int
3361 SWIG_AsVal_bool (PyObject *obj, bool *val)
3362 {
3363 if (obj == Py_True) {
3364 if (val) *val = true;
3365 return SWIG_OK;
3366 } else if (obj == Py_False) {
3367 if (val) *val = false;
3368 return SWIG_OK;
3369 } else {
3370 long v = 0;
3371 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3372 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3373 return res;
3374 }
3375 }
3376
3377 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3378 wxFileName fname = wxFileSystem::URLToFileName(url);
3379 return fname.GetFullPath();
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3383 wxImage& image,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, image, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3389 const wxBitmap& bitmap,
3390 long type) {
3391 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3392 }
3393
3394 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3395 PyObject* data) {
3396 if (! PyString_Check(data)) {
3397 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3398 "Expected string object"));
3399 return;
3400 }
3401
3402 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3403 void* ptr = (void*)PyString_AsString(data);
3404 size_t size = PyString_Size(data);
3405 wxPyEndBlockThreads(blocked);
3406
3407 wxMemoryFSHandler::AddFile(filename, ptr, size);
3408 }
3409
3410
3411 #include "wx/wxPython/pyistream.h"
3412
3413
3414 SWIGINTERN int
3415 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3416 {
3417 long v = 0;
3418 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3419 return SWIG_TypeError;
3420 }
3421 else if (val)
3422 *val = (unsigned long)v;
3423 return SWIG_OK;
3424 }
3425
3426
3427 SWIGINTERN int
3428 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3429 {
3430 unsigned long v;
3431 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3432 if (SWIG_IsOK(res)) {
3433 if ((v > UCHAR_MAX)) {
3434 return SWIG_OverflowError;
3435 } else {
3436 if (val) *val = static_cast< unsigned char >(v);
3437 }
3438 }
3439 return res;
3440 }
3441
3442
3443 SWIGINTERNINLINE PyObject *
3444 SWIG_From_unsigned_SS_char (unsigned char value)
3445 {
3446 return SWIG_From_unsigned_SS_long (value);
3447 }
3448
3449 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3450 wxImageHistogramEntry e = (*self)[key];
3451 return e.value;
3452 }
3453 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3454 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3459 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3460 colour.Green(),
3461 colour.Blue());
3462 wxImageHistogramEntry e = (*self)[key];
3463 return e.value;
3464 }
3465
3466 typedef unsigned char* buffer;
3467
3468
3469 // Pull the nested class out to the top level for SWIG's sake
3470 #define wxImage_RGBValue wxImage::RGBValue
3471 #define wxImage_HSVValue wxImage::HSVValue
3472
3473 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3474 if (width > 0 && height > 0)
3475 return new wxImage(width, height, clear);
3476 else
3477 return new wxImage;
3478 }
3479 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3480 return new wxImage(bitmap.ConvertToImage());
3481 }
3482 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3483 if (DATASIZE != width*height*3) {
3484 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3485 return NULL;
3486 }
3487
3488 // Copy the source data so the wxImage can clean it up later
3489 buffer copy = (buffer)malloc(DATASIZE);
3490 if (copy == NULL) {
3491 wxPyBLOCK_THREADS(PyErr_NoMemory());
3492 return NULL;
3493 }
3494 memcpy(copy, data, DATASIZE);
3495 return new wxImage(width, height, copy, false);
3496 }
3497 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3498 if (DATASIZE != width*height*3) {
3499 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3500 return NULL;
3501 }
3502 if (ALPHASIZE != width*height) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer dcopy = (buffer)malloc(DATASIZE);
3509 if (dcopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(dcopy, data, DATASIZE);
3514
3515 buffer acopy = (buffer)malloc(ALPHASIZE);
3516 if (acopy == NULL) {
3517 wxPyBLOCK_THREADS(PyErr_NoMemory());
3518 return NULL;
3519 }
3520 memcpy(acopy, alpha, ALPHASIZE);
3521
3522 return new wxImage(width, height, dcopy, acopy, false);
3523 }
3524 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3525 wxSize size(self->GetWidth(), self->GetHeight());
3526 return size;
3527 }
3528 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3529 buffer data = self->GetData();
3530 int len = self->GetWidth() * self->GetHeight() * 3;
3531 PyObject* rv;
3532 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3533 return rv;
3534 }
3535 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3536 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3537 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3538 return;
3539 }
3540 buffer copy = (buffer)malloc(DATASIZE);
3541 if (copy == NULL) {
3542 wxPyBLOCK_THREADS(PyErr_NoMemory());
3543 return;
3544 }
3545 memcpy(copy, data, DATASIZE);
3546 self->SetData(copy, false);
3547 // wxImage takes ownership of copy...
3548 }
3549 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3550 buffer data = self->GetData();
3551 int len = self->GetWidth() * self->GetHeight() * 3;
3552 PyObject* rv;
3553 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3554 return rv;
3555 }
3556 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3557 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return;
3560 }
3561 self->SetData(data, true);
3562 }
3563 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3564 buffer data = self->GetAlpha();
3565 if (! data) {
3566 RETURN_NONE();
3567 } else {
3568 int len = self->GetWidth() * self->GetHeight();
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3571 return rv;
3572 }
3573 }
3574 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3575 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3577 return;
3578 }
3579 buffer acopy = (buffer)malloc(ALPHASIZE);
3580 if (acopy == NULL) {
3581 wxPyBLOCK_THREADS(PyErr_NoMemory());
3582 return;
3583 }
3584 memcpy(acopy, alpha, ALPHASIZE);
3585 self->SetAlpha(acopy, false);
3586 // wxImage takes ownership of acopy...
3587 }
3588 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3589 buffer data = self->GetAlpha();
3590 int len = self->GetWidth() * self->GetHeight();
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3596 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3598 return;
3599 }
3600 self->SetAlpha(alpha, true);
3601 }
3602 SWIGINTERN PyObject *wxImage_GetHandlers(){
3603 wxList& list = wxImage::GetHandlers();
3604 return wxPy_ConvertList(&list);
3605 }
3606 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3607 wxBitmap bitmap(*self, depth);
3608 return bitmap;
3609 }
3610 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3611 wxImage mono = self->ConvertToMono( red, green, blue );
3612 wxBitmap bitmap( mono, 1 );
3613 return bitmap;
3614 }
3615 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3616 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3617 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3618 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3619 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3620 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3621 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3622 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3623 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3624 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3625 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3626 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3627 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3628 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3629 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3630
3631 #include <wx/quantize.h>
3632
3633 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3634 return wxQuantize::Quantize(src, dest,
3635 //NULL, // palette
3636 desiredNoColours,
3637 NULL, // eightBitData
3638 flags);
3639 }
3640 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3641 if (PyCallable_Check(func)) {
3642 self->Connect(id, lastId, eventType,
3643 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3644 new wxPyCallback(func));
3645 }
3646 else if (func == Py_None) {
3647 self->Disconnect(id, lastId, eventType,
3648 (wxObjectEventFunction)
3649 &wxPyCallback::EventThunker);
3650 }
3651 else {
3652 wxPyBLOCK_THREADS(
3653 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3654 }
3655 }
3656 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3657 return self->Disconnect(id, lastId, eventType,
3658 (wxObjectEventFunction)
3659 &wxPyCallback::EventThunker);
3660 }
3661 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3662 if (_self && _self != Py_None) {
3663 self->SetClientObject(new wxPyOORClientData(_self, incref));
3664 }
3665 else {
3666 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3667 if (data) {
3668 self->SetClientObject(NULL); // This will delete it too
3669 }
3670 }
3671 }
3672
3673 #if ! wxUSE_HOTKEY
3674 #define wxEVT_HOTKEY -9999
3675 #endif
3676
3677 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3678 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3679 if (data) {
3680 Py_INCREF(data->m_obj);
3681 return data->m_obj;
3682 } else {
3683 Py_INCREF(Py_None);
3684 return Py_None;
3685 }
3686 }
3687 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3688 wxPyClientData* data = new wxPyClientData(clientData);
3689 self->SetClientObject(data);
3690 }
3691 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3692 #if wxUSE_UNICODE
3693 return self->GetUnicodeKey();
3694 #else
3695 return 0;
3696 #endif
3697 }
3698 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3699 #if wxUSE_UNICODE
3700 self->m_uniChar = uniChar;
3701 #endif
3702 }
3703
3704 SWIGINTERNINLINE PyObject *
3705 SWIG_From_unsigned_SS_int (unsigned int value)
3706 {
3707 return SWIG_From_unsigned_SS_long (value);
3708 }
3709
3710
3711 SWIGINTERN int
3712 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3713 {
3714 unsigned long v;
3715 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3716 if (SWIG_IsOK(res)) {
3717 if ((v > UINT_MAX)) {
3718 return SWIG_OverflowError;
3719 } else {
3720 if (val) *val = static_cast< unsigned int >(v);
3721 }
3722 }
3723 return res;
3724 }
3725
3726 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3727 self->m_size = size;
3728 }
3729 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3730 int count = self->GetNumberOfFiles();
3731 wxString* files = self->GetFiles();
3732 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3733 PyObject* list = PyList_New(count);
3734
3735 if (!list) {
3736 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3737 wxPyEndBlockThreads(blocked);
3738 return NULL;
3739 }
3740
3741 for (int i=0; i<count; i++) {
3742 PyList_SetItem(list, i, wx2PyString(files[i]));
3743 }
3744 wxPyEndBlockThreads(blocked);
3745 return list;
3746 }
3747
3748
3749 SWIGINTERN wxPyApp *new_wxPyApp(){
3750 wxPythonApp = new wxPyApp();
3751 return wxPythonApp;
3752 }
3753 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3754
3755 void wxApp_CleanUp() {
3756 __wxPyCleanup();
3757 }
3758
3759
3760 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3761
3762
3763
3764
3765
3766 SWIGINTERNINLINE PyObject *
3767 SWIG_FromCharPtr(const char *cptr)
3768 {
3769 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3770 }
3771
3772
3773 #if 0 // #ifdef __WXMAC__
3774
3775 // A dummy class that raises an exception if used...
3776 class wxEventLoop
3777 {
3778 public:
3779 wxEventLoop() { wxPyRaiseNotImplemented(); }
3780 int Run() { return 0; }
3781 void Exit(int rc = 0) {}
3782 bool Pending() const { return false; }
3783 bool Dispatch() { return false; }
3784 bool IsRunning() const { return false; }
3785 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3786 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3787 };
3788
3789 #else
3790
3791 #include <wx/evtloop.h>
3792
3793 #endif
3794
3795
3796
3797 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3798 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3799 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3800 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3801 wxWindowList& list = self->GetChildren();
3802 return wxPy_ConvertList(&list);
3803 }
3804 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3805 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3806 #if wxUSE_HOTKEY
3807 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3808 #else
3809 return false;
3810 #endif
3811 }
3812 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3813
3814
3815
3816 return false;
3817
3818 }
3819 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3820 return wxPyGetWinHandle(self);
3821 }
3822 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3823 self->AssociateHandle((WXWidget)handle);
3824 }
3825 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3826
3827 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3828 return wxWindow::FindWindowById(id, parent);
3829 }
3830
3831 wxWindow* wxFindWindowByName( const wxString& name,
3832 const wxWindow *parent = NULL ) {
3833 return wxWindow::FindWindowByName(name, parent);
3834 }
3835
3836 wxWindow* wxFindWindowByLabel( const wxString& label,
3837 const wxWindow *parent = NULL ) {
3838 return wxWindow::FindWindowByLabel(label, parent);
3839 }
3840
3841
3842 #ifdef __WXMSW__
3843 #include <wx/msw/private.h> // to get wxGetWindowId
3844 #endif
3845
3846
3847 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3848 #ifdef __WXMSW__
3849 WXHWND hWnd = (WXHWND)_hWnd;
3850 long id = wxGetWindowId(hWnd);
3851 wxWindow* win = new wxWindow;
3852 if (parent)
3853 parent->AddChild(win);
3854 win->SetEventHandler(win);
3855 win->SetHWND(hWnd);
3856 win->SetId(id);
3857 win->SubclassWin(hWnd);
3858 win->AdoptAttributesFromHWND();
3859 win->SetupColours();
3860 return win;
3861 #else
3862 wxPyRaiseNotImplemented();
3863 return NULL;
3864 #endif
3865 }
3866
3867
3868 PyObject* GetTopLevelWindows() {
3869 return wxPy_ConvertList(&wxTopLevelWindows);
3870 }
3871
3872
3873 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3874 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3875 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3876
3877 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3878
3879
3880 SWIGINTERNINLINE int
3881 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3882 {
3883 unsigned long v;
3884 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3885 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3886 return res;
3887 }
3888
3889 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3890 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3891 wxMenuItemList& list = self->GetMenuItems();
3892 return wxPy_ConvertList(&list);
3893 }
3894 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3895 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3896 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3897 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3898 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3899 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3900 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3901 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3902 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3903 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3904 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3905 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3906 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3907 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3908 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3909 static const wxString wxPyControlNameStr(wxControlNameStr);
3910 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3911 if (clientData) {
3912 wxPyClientData* data = new wxPyClientData(clientData);
3913 return self->Append(item, data);
3914 } else
3915 return self->Append(item);
3916 }
3917 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3918 if (clientData) {
3919 wxPyClientData* data = new wxPyClientData(clientData);
3920 return self->Insert(item, pos, data);
3921 } else
3922 return self->Insert(item, pos);
3923 }
3924 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3925 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3926 if (data) {
3927 Py_INCREF(data->m_obj);
3928 return data->m_obj;
3929 } else {
3930 Py_INCREF(Py_None);
3931 return Py_None;
3932 }
3933 }
3934 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3935 wxPyClientData* data = new wxPyClientData(clientData);
3936 self->SetClientObject(n, data);
3937 }
3938
3939
3940 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3941 wxPyUserData* data = NULL;
3942 if ( userData ) {
3943 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3944 data = new wxPyUserData(userData);
3945 wxPyEndBlockThreads(blocked);
3946 }
3947 return new wxSizerItem(window, proportion, flag, border, data);
3948 }
3949 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3950 wxPyUserData* data = NULL;
3951 if ( userData ) {
3952 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3953 data = new wxPyUserData(userData);
3954 wxPyEndBlockThreads(blocked);
3955 }
3956 return new wxSizerItem(width, height, proportion, flag, border, data);
3957 }
3958 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3959 wxPyUserData* data = NULL;
3960 if ( userData ) {
3961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3962 data = new wxPyUserData(userData);
3963 wxPyEndBlockThreads(blocked);
3964 }
3965 return new wxSizerItem(sizer, proportion, flag, border, data);
3966 }
3967
3968 #include <float.h>
3969
3970
3971 SWIGINTERN int
3972 SWIG_AsVal_float (PyObject * obj, float *val)
3973 {
3974 double v;
3975 int res = SWIG_AsVal_double (obj, &v);
3976 if (SWIG_IsOK(res)) {
3977 if ((v < -FLT_MAX || v > FLT_MAX)) {
3978 return SWIG_OverflowError;
3979 } else {
3980 if (val) *val = static_cast< float >(v);
3981 }
3982 }
3983 return res;
3984 }
3985
3986
3987 SWIGINTERNINLINE PyObject *
3988 SWIG_From_float (float value)
3989 {
3990 return SWIG_From_double (value);
3991 }
3992
3993 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3994 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3995 if (data) {
3996 Py_INCREF(data->m_obj);
3997 return data->m_obj;
3998 } else {
3999 Py_INCREF(Py_None);
4000 return Py_None;
4001 }
4002 }
4003 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4004 wxPyUserData* data = NULL;
4005 if ( userData ) {
4006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4007 data = new wxPyUserData(userData);
4008 wxPyEndBlockThreads(blocked);
4009 }
4010 self->SetUserData(data);
4011 }
4012
4013 // Figure out the type of the sizer item
4014
4015 struct wxPySizerItemInfo {
4016 wxPySizerItemInfo()
4017 : window(NULL), sizer(NULL), gotSize(false),
4018 size(wxDefaultSize), gotPos(false), pos(-1)
4019 {}
4020
4021 wxWindow* window;
4022 wxSizer* sizer;
4023 bool gotSize;
4024 wxSize size;
4025 bool gotPos;
4026 int pos;
4027 };
4028
4029 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4030
4031 wxPySizerItemInfo info;
4032 wxSize size;
4033 wxSize* sizePtr = &size;
4034
4035 // Find out what the type of the item is
4036 // try wxWindow
4037 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4038 PyErr_Clear();
4039 info.window = NULL;
4040
4041 // try wxSizer
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4043 PyErr_Clear();
4044 info.sizer = NULL;
4045
4046 // try wxSize or (w,h)
4047 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4048 info.size = *sizePtr;
4049 info.gotSize = true;
4050 }
4051
4052 // or a single int
4053 if (checkIdx && PyInt_Check(item)) {
4054 info.pos = PyInt_AsLong(item);
4055 info.gotPos = true;
4056 }
4057 }
4058 }
4059
4060 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4061 // no expected type, figure out what kind of error message to generate
4062 if ( !checkSize && !checkIdx )
4063 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4064 else if ( checkSize && !checkIdx )
4065 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4066 else if ( !checkSize && checkIdx)
4067 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4068 else
4069 // can this one happen?
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4071 }
4072
4073 return info;
4074 }
4075
4076 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4077 if (!self->GetClientObject())
4078 self->SetClientObject(new wxPyOORClientData(_self));
4079 }
4080 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4081
4082 wxPyUserData* data = NULL;
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4085 if ( userData && (info.window || info.sizer || info.gotSize) )
4086 data = new wxPyUserData(userData);
4087 if ( info.sizer )
4088 PyObject_SetAttrString(item,"thisown",Py_False);
4089 wxPyEndBlockThreads(blocked);
4090
4091 // Now call the real Add method if a valid item type was found
4092 if ( info.window )
4093 return self->Add(info.window, proportion, flag, border, data);
4094 else if ( info.sizer )
4095 return self->Add(info.sizer, proportion, flag, border, data);
4096 else if (info.gotSize)
4097 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4098 proportion, flag, border, data);
4099 else
4100 return NULL;
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Insert method if a valid item type was found
4114 if ( info.window )
4115 return self->Insert(before, info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Insert(before, info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Prepend method if a valid item type was found
4136 if ( info.window )
4137 return self->Prepend(info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Prepend(info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->Remove(info.window);
4152 else if ( info.sizer )
4153 return self->Remove(info.sizer);
4154 else if ( info.gotPos )
4155 return self->Remove(info.pos);
4156 else
4157 return false;
4158 }
4159 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 return self->Detach(info.window);
4165 else if ( info.sizer )
4166 return self->Detach(info.sizer);
4167 else if ( info.gotPos )
4168 return self->Detach(info.pos);
4169 else
4170 return false;
4171 }
4172 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 return self->GetItem(info.window);
4178 else if ( info.sizer )
4179 return self->GetItem(info.sizer);
4180 else if ( info.gotPos )
4181 return self->GetItem(info.pos);
4182 else
4183 return NULL;
4184 }
4185 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4188 wxPyEndBlockThreads(blocked);
4189 if ( info.window )
4190 self->SetItemMinSize(info.window, size);
4191 else if ( info.sizer )
4192 self->SetItemMinSize(info.sizer, size);
4193 else if ( info.gotPos )
4194 self->SetItemMinSize(info.pos, size);
4195 }
4196 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4197 wxSizerItemList& list = self->GetChildren();
4198 return wxPy_ConvertList(&list);
4199 }
4200 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4203 wxPyEndBlockThreads(blocked);
4204 if ( info.window )
4205 return self->Show(info.window, show, recursive);
4206 else if ( info.sizer )
4207 return self->Show(info.sizer, show, recursive);
4208 else if ( info.gotPos )
4209 return self->Show(info.pos, show);
4210 else
4211 return false;
4212 }
4213 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4216 wxPyEndBlockThreads(blocked);
4217 if ( info.window )
4218 return self->IsShown(info.window);
4219 else if ( info.sizer )
4220 return self->IsShown(info.sizer);
4221 else if ( info.gotPos )
4222 return self->IsShown(info.pos);
4223 else
4224 return false;
4225 }
4226
4227 // See pyclasses.h
4228 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4229 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4230 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4231
4232
4233
4234
4235 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4236 {
4237 if (source == Py_None) {
4238 **obj = wxGBPosition(-1,-1);
4239 return true;
4240 }
4241 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4242 }
4243
4244 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4245 {
4246 if (source == Py_None) {
4247 **obj = wxGBSpan(-1,-1);
4248 return true;
4249 }
4250 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4251 }
4252
4253
4254 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4255 wxGBPosition temp, *obj = &temp;
4256 if ( other == Py_None ) return false;
4257 if ( ! wxGBPosition_helper(other, &obj) ) {
4258 PyErr_Clear();
4259 return false;
4260 }
4261 return self->operator==(*obj);
4262 }
4263 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4264 wxGBPosition temp, *obj = &temp;
4265 if ( other == Py_None ) return true;
4266 if ( ! wxGBPosition_helper(other, &obj)) {
4267 PyErr_Clear();
4268 return true;
4269 }
4270 return self->operator!=(*obj);
4271 }
4272 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4273 self->SetRow(row);
4274 self->SetCol(col);
4275 }
4276 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4277 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4278 PyObject* tup = PyTuple_New(2);
4279 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4280 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4281 wxPyEndBlockThreads(blocked);
4282 return tup;
4283 }
4284 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4285 wxGBSpan temp, *obj = &temp;
4286 if ( other == Py_None ) return false;
4287 if ( ! wxGBSpan_helper(other, &obj) ) {
4288 PyErr_Clear();
4289 return false;
4290 }
4291 return self->operator==(*obj);
4292 }
4293 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4294 wxGBSpan temp, *obj = &temp;
4295 if ( other == Py_None ) return true;
4296 if ( ! wxGBSpan_helper(other, &obj)) {
4297 PyErr_Clear();
4298 return true;
4299 }
4300 return self->operator!=(*obj);
4301 }
4302 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4303 self->SetRowspan(rowspan);
4304 self->SetColspan(colspan);
4305 }
4306 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 PyObject* tup = PyTuple_New(2);
4309 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4310 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4311 wxPyEndBlockThreads(blocked);
4312 return tup;
4313 }
4314 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4315 wxPyUserData* data = NULL;
4316 if ( userData ) {
4317 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4318 data = new wxPyUserData(userData);
4319 wxPyEndBlockThreads(blocked);
4320 }
4321 return new wxGBSizerItem(window, pos, span, flag, border, data);
4322 }
4323 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4324 wxPyUserData* data = NULL;
4325 if ( userData ) {
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 data = new wxPyUserData(userData);
4328 wxPyEndBlockThreads(blocked);
4329 }
4330 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4331 }
4332 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4333 wxPyUserData* data = NULL;
4334 if ( userData ) {
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 data = new wxPyUserData(userData);
4337 wxPyEndBlockThreads(blocked);
4338 }
4339 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4340 }
4341 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4342 int row, col;
4343 self->GetEndPos(row, col);
4344 return wxGBPosition(row, col);
4345 }
4346 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4347
4348 wxPyUserData* data = NULL;
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4351 if ( userData && (info.window || info.sizer || info.gotSize) )
4352 data = new wxPyUserData(userData);
4353 if ( info.sizer )
4354 PyObject_SetAttrString(item,"thisown",Py_False);
4355 wxPyEndBlockThreads(blocked);
4356
4357 // Now call the real Add method if a valid item type was found
4358 if ( info.window )
4359 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4360 else if ( info.sizer )
4361 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4362 else if (info.gotSize)
4363 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4364 pos, span, flag, border, data);
4365 return NULL;
4366 }
4367
4368
4369 #ifdef __cplusplus
4370 extern "C" {
4371 #endif
4372 SWIGINTERN int EmptyString_set(PyObject *) {
4373 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4374 return 1;
4375 }
4376
4377
4378 SWIGINTERN PyObject *EmptyString_get(void) {
4379 PyObject *pyobj = 0;
4380
4381 {
4382 #if wxUSE_UNICODE
4383 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4384 #else
4385 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4386 #endif
4387 }
4388 return pyobj;
4389 }
4390
4391
4392 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4393 PyObject *resultobj = 0;
4394 wxObject *arg1 = (wxObject *) 0 ;
4395 wxString result;
4396 void *argp1 = 0 ;
4397 int res1 = 0 ;
4398 PyObject *swig_obj[1] ;
4399
4400 if (!args) SWIG_fail;
4401 swig_obj[0] = args;
4402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4403 if (!SWIG_IsOK(res1)) {
4404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4405 }
4406 arg1 = reinterpret_cast< wxObject * >(argp1);
4407 {
4408 PyThreadState* __tstate = wxPyBeginAllowThreads();
4409 result = wxObject_GetClassName(arg1);
4410 wxPyEndAllowThreads(__tstate);
4411 if (PyErr_Occurred()) SWIG_fail;
4412 }
4413 {
4414 #if wxUSE_UNICODE
4415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4416 #else
4417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4418 #endif
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4427 PyObject *resultobj = 0;
4428 wxObject *arg1 = (wxObject *) 0 ;
4429 void *argp1 = 0 ;
4430 int res1 = 0 ;
4431 PyObject *swig_obj[1] ;
4432
4433 if (!args) SWIG_fail;
4434 swig_obj[0] = args;
4435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4436 if (!SWIG_IsOK(res1)) {
4437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4438 }
4439 arg1 = reinterpret_cast< wxObject * >(argp1);
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 wxObject_Destroy(arg1);
4443 wxPyEndAllowThreads(__tstate);
4444 if (PyErr_Occurred()) SWIG_fail;
4445 }
4446 resultobj = SWIG_Py_Void();
4447 return resultobj;
4448 fail:
4449 return NULL;
4450 }
4451
4452
4453 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4454 PyObject *obj;
4455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4456 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4457 return SWIG_Py_Void();
4458 }
4459
4460 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *resultobj = 0;
4462 wxSize *arg1 = (wxSize *) 0 ;
4463 int arg2 ;
4464 void *argp1 = 0 ;
4465 int res1 = 0 ;
4466 int val2 ;
4467 int ecode2 = 0 ;
4468 PyObject *swig_obj[2] ;
4469
4470 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4472 if (!SWIG_IsOK(res1)) {
4473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4474 }
4475 arg1 = reinterpret_cast< wxSize * >(argp1);
4476 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4477 if (!SWIG_IsOK(ecode2)) {
4478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4479 }
4480 arg2 = static_cast< int >(val2);
4481 if (arg1) (arg1)->x = arg2;
4482
4483 resultobj = SWIG_Py_Void();
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4491 PyObject *resultobj = 0;
4492 wxSize *arg1 = (wxSize *) 0 ;
4493 int result;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4503 }
4504 arg1 = reinterpret_cast< wxSize * >(argp1);
4505 result = (int) ((arg1)->x);
4506 resultobj = SWIG_From_int(static_cast< int >(result));
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int arg2 ;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 int val2 ;
4520 int ecode2 = 0 ;
4521 PyObject *swig_obj[2] ;
4522
4523 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4525 if (!SWIG_IsOK(res1)) {
4526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4527 }
4528 arg1 = reinterpret_cast< wxSize * >(argp1);
4529 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4530 if (!SWIG_IsOK(ecode2)) {
4531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4532 }
4533 arg2 = static_cast< int >(val2);
4534 if (arg1) (arg1)->y = arg2;
4535
4536 resultobj = SWIG_Py_Void();
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4544 PyObject *resultobj = 0;
4545 wxSize *arg1 = (wxSize *) 0 ;
4546 int result;
4547 void *argp1 = 0 ;
4548 int res1 = 0 ;
4549 PyObject *swig_obj[1] ;
4550
4551 if (!args) SWIG_fail;
4552 swig_obj[0] = args;
4553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4554 if (!SWIG_IsOK(res1)) {
4555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4556 }
4557 arg1 = reinterpret_cast< wxSize * >(argp1);
4558 result = (int) ((arg1)->y);
4559 resultobj = SWIG_From_int(static_cast< int >(result));
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4567 PyObject *resultobj = 0;
4568 int arg1 = (int) 0 ;
4569 int arg2 = (int) 0 ;
4570 wxSize *result = 0 ;
4571 int val1 ;
4572 int ecode1 = 0 ;
4573 int val2 ;
4574 int ecode2 = 0 ;
4575 PyObject * obj0 = 0 ;
4576 PyObject * obj1 = 0 ;
4577 char * kwnames[] = {
4578 (char *) "w",(char *) "h", NULL
4579 };
4580
4581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4582 if (obj0) {
4583 ecode1 = SWIG_AsVal_int(obj0, &val1);
4584 if (!SWIG_IsOK(ecode1)) {
4585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4586 }
4587 arg1 = static_cast< int >(val1);
4588 }
4589 if (obj1) {
4590 ecode2 = SWIG_AsVal_int(obj1, &val2);
4591 if (!SWIG_IsOK(ecode2)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4593 }
4594 arg2 = static_cast< int >(val2);
4595 }
4596 {
4597 PyThreadState* __tstate = wxPyBeginAllowThreads();
4598 result = (wxSize *)new wxSize(arg1,arg2);
4599 wxPyEndAllowThreads(__tstate);
4600 if (PyErr_Occurred()) SWIG_fail;
4601 }
4602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4603 return resultobj;
4604 fail:
4605 return NULL;
4606 }
4607
4608
4609 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4610 PyObject *resultobj = 0;
4611 wxSize *arg1 = (wxSize *) 0 ;
4612 void *argp1 = 0 ;
4613 int res1 = 0 ;
4614 PyObject *swig_obj[1] ;
4615
4616 if (!args) SWIG_fail;
4617 swig_obj[0] = args;
4618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4619 if (!SWIG_IsOK(res1)) {
4620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4621 }
4622 arg1 = reinterpret_cast< wxSize * >(argp1);
4623 {
4624 PyThreadState* __tstate = wxPyBeginAllowThreads();
4625 delete arg1;
4626
4627 wxPyEndAllowThreads(__tstate);
4628 if (PyErr_Occurred()) SWIG_fail;
4629 }
4630 resultobj = SWIG_Py_Void();
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4638 PyObject *resultobj = 0;
4639 wxSize *arg1 = (wxSize *) 0 ;
4640 PyObject *arg2 = (PyObject *) 0 ;
4641 bool result;
4642 void *argp1 = 0 ;
4643 int res1 = 0 ;
4644 PyObject * obj0 = 0 ;
4645 PyObject * obj1 = 0 ;
4646 char * kwnames[] = {
4647 (char *) "self",(char *) "other", NULL
4648 };
4649
4650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4652 if (!SWIG_IsOK(res1)) {
4653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4654 }
4655 arg1 = reinterpret_cast< wxSize * >(argp1);
4656 arg2 = obj1;
4657 {
4658 result = (bool)wxSize___eq__(arg1,arg2);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 {
4662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4663 }
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj = 0;
4672 wxSize *arg1 = (wxSize *) 0 ;
4673 PyObject *arg2 = (PyObject *) 0 ;
4674 bool result;
4675 void *argp1 = 0 ;
4676 int res1 = 0 ;
4677 PyObject * obj0 = 0 ;
4678 PyObject * obj1 = 0 ;
4679 char * kwnames[] = {
4680 (char *) "self",(char *) "other", NULL
4681 };
4682
4683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4685 if (!SWIG_IsOK(res1)) {
4686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4687 }
4688 arg1 = reinterpret_cast< wxSize * >(argp1);
4689 arg2 = obj1;
4690 {
4691 result = (bool)wxSize___ne__(arg1,arg2);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 {
4695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4696 }
4697 return resultobj;
4698 fail:
4699 return NULL;
4700 }
4701
4702
4703 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4704 PyObject *resultobj = 0;
4705 wxSize *arg1 = (wxSize *) 0 ;
4706 wxSize *arg2 = 0 ;
4707 wxSize result;
4708 void *argp1 = 0 ;
4709 int res1 = 0 ;
4710 wxSize temp2 ;
4711 PyObject * obj0 = 0 ;
4712 PyObject * obj1 = 0 ;
4713 char * kwnames[] = {
4714 (char *) "self",(char *) "sz", NULL
4715 };
4716
4717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4719 if (!SWIG_IsOK(res1)) {
4720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4721 }
4722 arg1 = reinterpret_cast< wxSize * >(argp1);
4723 {
4724 arg2 = &temp2;
4725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 result = (arg1)->operator +((wxSize const &)*arg2);
4730 wxPyEndAllowThreads(__tstate);
4731 if (PyErr_Occurred()) SWIG_fail;
4732 }
4733 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4734 return resultobj;
4735 fail:
4736 return NULL;
4737 }
4738
4739
4740 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj = 0;
4742 wxSize *arg1 = (wxSize *) 0 ;
4743 wxSize *arg2 = 0 ;
4744 wxSize result;
4745 void *argp1 = 0 ;
4746 int res1 = 0 ;
4747 wxSize temp2 ;
4748 PyObject * obj0 = 0 ;
4749 PyObject * obj1 = 0 ;
4750 char * kwnames[] = {
4751 (char *) "self",(char *) "sz", NULL
4752 };
4753
4754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4756 if (!SWIG_IsOK(res1)) {
4757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4758 }
4759 arg1 = reinterpret_cast< wxSize * >(argp1);
4760 {
4761 arg2 = &temp2;
4762 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4763 }
4764 {
4765 PyThreadState* __tstate = wxPyBeginAllowThreads();
4766 result = (arg1)->operator -((wxSize const &)*arg2);
4767 wxPyEndAllowThreads(__tstate);
4768 if (PyErr_Occurred()) SWIG_fail;
4769 }
4770 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4771 return resultobj;
4772 fail:
4773 return NULL;
4774 }
4775
4776
4777 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4778 PyObject *resultobj = 0;
4779 wxSize *arg1 = (wxSize *) 0 ;
4780 wxSize *arg2 = 0 ;
4781 void *argp1 = 0 ;
4782 int res1 = 0 ;
4783 wxSize temp2 ;
4784 PyObject * obj0 = 0 ;
4785 PyObject * obj1 = 0 ;
4786 char * kwnames[] = {
4787 (char *) "self",(char *) "sz", NULL
4788 };
4789
4790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4792 if (!SWIG_IsOK(res1)) {
4793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4794 }
4795 arg1 = reinterpret_cast< wxSize * >(argp1);
4796 {
4797 arg2 = &temp2;
4798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4799 }
4800 {
4801 PyThreadState* __tstate = wxPyBeginAllowThreads();
4802 (arg1)->IncTo((wxSize const &)*arg2);
4803 wxPyEndAllowThreads(__tstate);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_Py_Void();
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4814 PyObject *resultobj = 0;
4815 wxSize *arg1 = (wxSize *) 0 ;
4816 wxSize *arg2 = 0 ;
4817 void *argp1 = 0 ;
4818 int res1 = 0 ;
4819 wxSize temp2 ;
4820 PyObject * obj0 = 0 ;
4821 PyObject * obj1 = 0 ;
4822 char * kwnames[] = {
4823 (char *) "self",(char *) "sz", NULL
4824 };
4825
4826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4828 if (!SWIG_IsOK(res1)) {
4829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4830 }
4831 arg1 = reinterpret_cast< wxSize * >(argp1);
4832 {
4833 arg2 = &temp2;
4834 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4835 }
4836 {
4837 PyThreadState* __tstate = wxPyBeginAllowThreads();
4838 (arg1)->DecTo((wxSize const &)*arg2);
4839 wxPyEndAllowThreads(__tstate);
4840 if (PyErr_Occurred()) SWIG_fail;
4841 }
4842 resultobj = SWIG_Py_Void();
4843 return resultobj;
4844 fail:
4845 return NULL;
4846 }
4847
4848
4849 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4850 PyObject *resultobj = 0;
4851 wxSize *arg1 = (wxSize *) 0 ;
4852 int arg2 ;
4853 int arg3 ;
4854 void *argp1 = 0 ;
4855 int res1 = 0 ;
4856 int val2 ;
4857 int ecode2 = 0 ;
4858 int val3 ;
4859 int ecode3 = 0 ;
4860 PyObject * obj0 = 0 ;
4861 PyObject * obj1 = 0 ;
4862 PyObject * obj2 = 0 ;
4863 char * kwnames[] = {
4864 (char *) "self",(char *) "w",(char *) "h", NULL
4865 };
4866
4867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4869 if (!SWIG_IsOK(res1)) {
4870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4871 }
4872 arg1 = reinterpret_cast< wxSize * >(argp1);
4873 ecode2 = SWIG_AsVal_int(obj1, &val2);
4874 if (!SWIG_IsOK(ecode2)) {
4875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4876 }
4877 arg2 = static_cast< int >(val2);
4878 ecode3 = SWIG_AsVal_int(obj2, &val3);
4879 if (!SWIG_IsOK(ecode3)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4881 }
4882 arg3 = static_cast< int >(val3);
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 (arg1)->Set(arg2,arg3);
4886 wxPyEndAllowThreads(__tstate);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 int arg2 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 int val2 ;
4903 int ecode2 = 0 ;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 char * kwnames[] = {
4907 (char *) "self",(char *) "w", NULL
4908 };
4909
4910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 ecode2 = SWIG_AsVal_int(obj1, &val2);
4917 if (!SWIG_IsOK(ecode2)) {
4918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4919 }
4920 arg2 = static_cast< int >(val2);
4921 {
4922 PyThreadState* __tstate = wxPyBeginAllowThreads();
4923 (arg1)->SetWidth(arg2);
4924 wxPyEndAllowThreads(__tstate);
4925 if (PyErr_Occurred()) SWIG_fail;
4926 }
4927 resultobj = SWIG_Py_Void();
4928 return resultobj;
4929 fail:
4930 return NULL;
4931 }
4932
4933
4934 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4935 PyObject *resultobj = 0;
4936 wxSize *arg1 = (wxSize *) 0 ;
4937 int arg2 ;
4938 void *argp1 = 0 ;
4939 int res1 = 0 ;
4940 int val2 ;
4941 int ecode2 = 0 ;
4942 PyObject * obj0 = 0 ;
4943 PyObject * obj1 = 0 ;
4944 char * kwnames[] = {
4945 (char *) "self",(char *) "h", NULL
4946 };
4947
4948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4952 }
4953 arg1 = reinterpret_cast< wxSize * >(argp1);
4954 ecode2 = SWIG_AsVal_int(obj1, &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4957 }
4958 arg2 = static_cast< int >(val2);
4959 {
4960 PyThreadState* __tstate = wxPyBeginAllowThreads();
4961 (arg1)->SetHeight(arg2);
4962 wxPyEndAllowThreads(__tstate);
4963 if (PyErr_Occurred()) SWIG_fail;
4964 }
4965 resultobj = SWIG_Py_Void();
4966 return resultobj;
4967 fail:
4968 return NULL;
4969 }
4970
4971
4972 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4973 PyObject *resultobj = 0;
4974 wxSize *arg1 = (wxSize *) 0 ;
4975 int result;
4976 void *argp1 = 0 ;
4977 int res1 = 0 ;
4978 PyObject *swig_obj[1] ;
4979
4980 if (!args) SWIG_fail;
4981 swig_obj[0] = args;
4982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 {
4988 PyThreadState* __tstate = wxPyBeginAllowThreads();
4989 result = (int)((wxSize const *)arg1)->GetWidth();
4990 wxPyEndAllowThreads(__tstate);
4991 if (PyErr_Occurred()) SWIG_fail;
4992 }
4993 resultobj = SWIG_From_int(static_cast< int >(result));
4994 return resultobj;
4995 fail:
4996 return NULL;
4997 }
4998
4999
5000 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5001 PyObject *resultobj = 0;
5002 wxSize *arg1 = (wxSize *) 0 ;
5003 int result;
5004 void *argp1 = 0 ;
5005 int res1 = 0 ;
5006 PyObject *swig_obj[1] ;
5007
5008 if (!args) SWIG_fail;
5009 swig_obj[0] = args;
5010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 {
5016 PyThreadState* __tstate = wxPyBeginAllowThreads();
5017 result = (int)((wxSize const *)arg1)->GetHeight();
5018 wxPyEndAllowThreads(__tstate);
5019 if (PyErr_Occurred()) SWIG_fail;
5020 }
5021 resultobj = SWIG_From_int(static_cast< int >(result));
5022 return resultobj;
5023 fail:
5024 return NULL;
5025 }
5026
5027
5028 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5029 PyObject *resultobj = 0;
5030 wxSize *arg1 = (wxSize *) 0 ;
5031 bool result;
5032 void *argp1 = 0 ;
5033 int res1 = 0 ;
5034 PyObject *swig_obj[1] ;
5035
5036 if (!args) SWIG_fail;
5037 swig_obj[0] = args;
5038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5041 }
5042 arg1 = reinterpret_cast< wxSize * >(argp1);
5043 {
5044 PyThreadState* __tstate = wxPyBeginAllowThreads();
5045 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 {
5050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5051 }
5052 return resultobj;
5053 fail:
5054 return NULL;
5055 }
5056
5057
5058 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5059 PyObject *resultobj = 0;
5060 wxSize *arg1 = (wxSize *) 0 ;
5061 wxSize *arg2 = 0 ;
5062 void *argp1 = 0 ;
5063 int res1 = 0 ;
5064 wxSize temp2 ;
5065 PyObject * obj0 = 0 ;
5066 PyObject * obj1 = 0 ;
5067 char * kwnames[] = {
5068 (char *) "self",(char *) "size", NULL
5069 };
5070
5071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5075 }
5076 arg1 = reinterpret_cast< wxSize * >(argp1);
5077 {
5078 arg2 = &temp2;
5079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5080 }
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 (arg1)->SetDefaults((wxSize const &)*arg2);
5084 wxPyEndAllowThreads(__tstate);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = SWIG_Py_Void();
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095 PyObject *resultobj = 0;
5096 wxSize *arg1 = (wxSize *) 0 ;
5097 PyObject *result = 0 ;
5098 void *argp1 = 0 ;
5099 int res1 = 0 ;
5100 PyObject *swig_obj[1] ;
5101
5102 if (!args) SWIG_fail;
5103 swig_obj[0] = args;
5104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5105 if (!SWIG_IsOK(res1)) {
5106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5107 }
5108 arg1 = reinterpret_cast< wxSize * >(argp1);
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = (PyObject *)wxSize_Get(arg1);
5112 wxPyEndAllowThreads(__tstate);
5113 if (PyErr_Occurred()) SWIG_fail;
5114 }
5115 resultobj = result;
5116 return resultobj;
5117 fail:
5118 return NULL;
5119 }
5120
5121
5122 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5123 PyObject *obj;
5124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5125 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5126 return SWIG_Py_Void();
5127 }
5128
5129 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5130 return SWIG_Python_InitShadowInstance(args);
5131 }
5132
5133 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134 PyObject *resultobj = 0;
5135 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5136 double arg2 ;
5137 void *argp1 = 0 ;
5138 int res1 = 0 ;
5139 double val2 ;
5140 int ecode2 = 0 ;
5141 PyObject *swig_obj[2] ;
5142
5143 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5145 if (!SWIG_IsOK(res1)) {
5146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5147 }
5148 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5149 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5150 if (!SWIG_IsOK(ecode2)) {
5151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5152 }
5153 arg2 = static_cast< double >(val2);
5154 if (arg1) (arg1)->x = arg2;
5155
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5164 PyObject *resultobj = 0;
5165 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5166 double result;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 PyObject *swig_obj[1] ;
5170
5171 if (!args) SWIG_fail;
5172 swig_obj[0] = args;
5173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5176 }
5177 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5178 result = (double) ((arg1)->x);
5179 resultobj = SWIG_From_double(static_cast< double >(result));
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5187 PyObject *resultobj = 0;
5188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5189 double arg2 ;
5190 void *argp1 = 0 ;
5191 int res1 = 0 ;
5192 double val2 ;
5193 int ecode2 = 0 ;
5194 PyObject *swig_obj[2] ;
5195
5196 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5200 }
5201 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5202 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5205 }
5206 arg2 = static_cast< double >(val2);
5207 if (arg1) (arg1)->y = arg2;
5208
5209 resultobj = SWIG_Py_Void();
5210 return resultobj;
5211 fail:
5212 return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5217 PyObject *resultobj = 0;
5218 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5219 double result;
5220 void *argp1 = 0 ;
5221 int res1 = 0 ;
5222 PyObject *swig_obj[1] ;
5223
5224 if (!args) SWIG_fail;
5225 swig_obj[0] = args;
5226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5227 if (!SWIG_IsOK(res1)) {
5228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5229 }
5230 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5231 result = (double) ((arg1)->y);
5232 resultobj = SWIG_From_double(static_cast< double >(result));
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5240 PyObject *resultobj = 0;
5241 double arg1 = (double) 0.0 ;
5242 double arg2 = (double) 0.0 ;
5243 wxRealPoint *result = 0 ;
5244 double val1 ;
5245 int ecode1 = 0 ;
5246 double val2 ;
5247 int ecode2 = 0 ;
5248 PyObject * obj0 = 0 ;
5249 PyObject * obj1 = 0 ;
5250 char * kwnames[] = {
5251 (char *) "x",(char *) "y", NULL
5252 };
5253
5254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5255 if (obj0) {
5256 ecode1 = SWIG_AsVal_double(obj0, &val1);
5257 if (!SWIG_IsOK(ecode1)) {
5258 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5259 }
5260 arg1 = static_cast< double >(val1);
5261 }
5262 if (obj1) {
5263 ecode2 = SWIG_AsVal_double(obj1, &val2);
5264 if (!SWIG_IsOK(ecode2)) {
5265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5266 }
5267 arg2 = static_cast< double >(val2);
5268 }
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5272 wxPyEndAllowThreads(__tstate);
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5283 PyObject *resultobj = 0;
5284 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 PyObject *swig_obj[1] ;
5288
5289 if (!args) SWIG_fail;
5290 swig_obj[0] = args;
5291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5292 if (!SWIG_IsOK(res1)) {
5293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5294 }
5295 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5296 {
5297 PyThreadState* __tstate = wxPyBeginAllowThreads();
5298 delete arg1;
5299
5300 wxPyEndAllowThreads(__tstate);
5301 if (PyErr_Occurred()) SWIG_fail;
5302 }
5303 resultobj = SWIG_Py_Void();
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj = 0;
5312 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5313 PyObject *arg2 = (PyObject *) 0 ;
5314 bool result;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char * kwnames[] = {
5320 (char *) "self",(char *) "other", NULL
5321 };
5322
5323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5325 if (!SWIG_IsOK(res1)) {
5326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5327 }
5328 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5329 arg2 = obj1;
5330 {
5331 result = (bool)wxRealPoint___eq__(arg1,arg2);
5332 if (PyErr_Occurred()) SWIG_fail;
5333 }
5334 {
5335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5336 }
5337 return resultobj;
5338 fail:
5339 return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5344 PyObject *resultobj = 0;
5345 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5346 PyObject *arg2 = (PyObject *) 0 ;
5347 bool result;
5348 void *argp1 = 0 ;
5349 int res1 = 0 ;
5350 PyObject * obj0 = 0 ;
5351 PyObject * obj1 = 0 ;
5352 char * kwnames[] = {
5353 (char *) "self",(char *) "other", NULL
5354 };
5355
5356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5360 }
5361 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5362 arg2 = obj1;
5363 {
5364 result = (bool)wxRealPoint___ne__(arg1,arg2);
5365 if (PyErr_Occurred()) SWIG_fail;
5366 }
5367 {
5368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5369 }
5370 return resultobj;
5371 fail:
5372 return NULL;
5373 }
5374
5375
5376 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5377 PyObject *resultobj = 0;
5378 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5379 wxRealPoint *arg2 = 0 ;
5380 wxRealPoint result;
5381 void *argp1 = 0 ;
5382 int res1 = 0 ;
5383 wxRealPoint temp2 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "pt", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",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___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 {
5397 arg2 = &temp2;
5398 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5399 }
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5403 wxPyEndAllowThreads(__tstate);
5404 if (PyErr_Occurred()) SWIG_fail;
5405 }
5406 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5407 return resultobj;
5408 fail:
5409 return NULL;
5410 }
5411
5412
5413 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj = 0;
5415 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5416 wxRealPoint *arg2 = 0 ;
5417 wxRealPoint result;
5418 void *argp1 = 0 ;
5419 int res1 = 0 ;
5420 wxRealPoint temp2 ;
5421 PyObject * obj0 = 0 ;
5422 PyObject * obj1 = 0 ;
5423 char * kwnames[] = {
5424 (char *) "self",(char *) "pt", NULL
5425 };
5426
5427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5429 if (!SWIG_IsOK(res1)) {
5430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5431 }
5432 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5433 {
5434 arg2 = &temp2;
5435 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5436 }
5437 {
5438 PyThreadState* __tstate = wxPyBeginAllowThreads();
5439 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5451 PyObject *resultobj = 0;
5452 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5453 double arg2 ;
5454 double arg3 ;
5455 void *argp1 = 0 ;
5456 int res1 = 0 ;
5457 double val2 ;
5458 int ecode2 = 0 ;
5459 double val3 ;
5460 int ecode3 = 0 ;
5461 PyObject * obj0 = 0 ;
5462 PyObject * obj1 = 0 ;
5463 PyObject * obj2 = 0 ;
5464 char * kwnames[] = {
5465 (char *) "self",(char *) "x",(char *) "y", NULL
5466 };
5467
5468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5470 if (!SWIG_IsOK(res1)) {
5471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5472 }
5473 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5474 ecode2 = SWIG_AsVal_double(obj1, &val2);
5475 if (!SWIG_IsOK(ecode2)) {
5476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5477 }
5478 arg2 = static_cast< double >(val2);
5479 ecode3 = SWIG_AsVal_double(obj2, &val3);
5480 if (!SWIG_IsOK(ecode3)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5482 }
5483 arg3 = static_cast< double >(val3);
5484 {
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 wxRealPoint_Set(arg1,arg2,arg3);
5487 wxPyEndAllowThreads(__tstate);
5488 if (PyErr_Occurred()) SWIG_fail;
5489 }
5490 resultobj = SWIG_Py_Void();
5491 return resultobj;
5492 fail:
5493 return NULL;
5494 }
5495
5496
5497 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5498 PyObject *resultobj = 0;
5499 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5500 PyObject *result = 0 ;
5501 void *argp1 = 0 ;
5502 int res1 = 0 ;
5503 PyObject *swig_obj[1] ;
5504
5505 if (!args) SWIG_fail;
5506 swig_obj[0] = args;
5507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5508 if (!SWIG_IsOK(res1)) {
5509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5510 }
5511 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5512 {
5513 PyThreadState* __tstate = wxPyBeginAllowThreads();
5514 result = (PyObject *)wxRealPoint_Get(arg1);
5515 wxPyEndAllowThreads(__tstate);
5516 if (PyErr_Occurred()) SWIG_fail;
5517 }
5518 resultobj = result;
5519 return resultobj;
5520 fail:
5521 return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5526 PyObject *obj;
5527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5528 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5529 return SWIG_Py_Void();
5530 }
5531
5532 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5533 return SWIG_Python_InitShadowInstance(args);
5534 }
5535
5536 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5537 PyObject *resultobj = 0;
5538 wxPoint *arg1 = (wxPoint *) 0 ;
5539 int arg2 ;
5540 void *argp1 = 0 ;
5541 int res1 = 0 ;
5542 int val2 ;
5543 int ecode2 = 0 ;
5544 PyObject *swig_obj[2] ;
5545
5546 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5548 if (!SWIG_IsOK(res1)) {
5549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5550 }
5551 arg1 = reinterpret_cast< wxPoint * >(argp1);
5552 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5553 if (!SWIG_IsOK(ecode2)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5555 }
5556 arg2 = static_cast< int >(val2);
5557 if (arg1) (arg1)->x = arg2;
5558
5559 resultobj = SWIG_Py_Void();
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 wxPoint *arg1 = (wxPoint *) 0 ;
5569 int result;
5570 void *argp1 = 0 ;
5571 int res1 = 0 ;
5572 PyObject *swig_obj[1] ;
5573
5574 if (!args) SWIG_fail;
5575 swig_obj[0] = args;
5576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxPoint * >(argp1);
5581 result = (int) ((arg1)->x);
5582 resultobj = SWIG_From_int(static_cast< int >(result));
5583 return resultobj;
5584 fail:
5585 return NULL;
5586 }
5587
5588
5589 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5590 PyObject *resultobj = 0;
5591 wxPoint *arg1 = (wxPoint *) 0 ;
5592 int arg2 ;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 int val2 ;
5596 int ecode2 = 0 ;
5597 PyObject *swig_obj[2] ;
5598
5599 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5601 if (!SWIG_IsOK(res1)) {
5602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5603 }
5604 arg1 = reinterpret_cast< wxPoint * >(argp1);
5605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5606 if (!SWIG_IsOK(ecode2)) {
5607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5608 }
5609 arg2 = static_cast< int >(val2);
5610 if (arg1) (arg1)->y = arg2;
5611
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5620 PyObject *resultobj = 0;
5621 wxPoint *arg1 = (wxPoint *) 0 ;
5622 int result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject *swig_obj[1] ;
5626
5627 if (!args) SWIG_fail;
5628 swig_obj[0] = args;
5629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5630 if (!SWIG_IsOK(res1)) {
5631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5632 }
5633 arg1 = reinterpret_cast< wxPoint * >(argp1);
5634 result = (int) ((arg1)->y);
5635 resultobj = SWIG_From_int(static_cast< int >(result));
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 int arg1 = (int) 0 ;
5645 int arg2 = (int) 0 ;
5646 wxPoint *result = 0 ;
5647 int val1 ;
5648 int ecode1 = 0 ;
5649 int val2 ;
5650 int ecode2 = 0 ;
5651 PyObject * obj0 = 0 ;
5652 PyObject * obj1 = 0 ;
5653 char * kwnames[] = {
5654 (char *) "x",(char *) "y", NULL
5655 };
5656
5657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5658 if (obj0) {
5659 ecode1 = SWIG_AsVal_int(obj0, &val1);
5660 if (!SWIG_IsOK(ecode1)) {
5661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5662 }
5663 arg1 = static_cast< int >(val1);
5664 }
5665 if (obj1) {
5666 ecode2 = SWIG_AsVal_int(obj1, &val2);
5667 if (!SWIG_IsOK(ecode2)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5669 }
5670 arg2 = static_cast< int >(val2);
5671 }
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 result = (wxPoint *)new wxPoint(arg1,arg2);
5675 wxPyEndAllowThreads(__tstate);
5676 if (PyErr_Occurred()) SWIG_fail;
5677 }
5678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5686 PyObject *resultobj = 0;
5687 wxPoint *arg1 = (wxPoint *) 0 ;
5688 void *argp1 = 0 ;
5689 int res1 = 0 ;
5690 PyObject *swig_obj[1] ;
5691
5692 if (!args) SWIG_fail;
5693 swig_obj[0] = args;
5694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5695 if (!SWIG_IsOK(res1)) {
5696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5697 }
5698 arg1 = reinterpret_cast< wxPoint * >(argp1);
5699 {
5700 PyThreadState* __tstate = wxPyBeginAllowThreads();
5701 delete arg1;
5702
5703 wxPyEndAllowThreads(__tstate);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = SWIG_Py_Void();
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5714 PyObject *resultobj = 0;
5715 wxPoint *arg1 = (wxPoint *) 0 ;
5716 PyObject *arg2 = (PyObject *) 0 ;
5717 bool result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 char * kwnames[] = {
5723 (char *) "self",(char *) "other", NULL
5724 };
5725
5726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5728 if (!SWIG_IsOK(res1)) {
5729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5730 }
5731 arg1 = reinterpret_cast< wxPoint * >(argp1);
5732 arg2 = obj1;
5733 {
5734 result = (bool)wxPoint___eq__(arg1,arg2);
5735 if (PyErr_Occurred()) SWIG_fail;
5736 }
5737 {
5738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5739 }
5740 return resultobj;
5741 fail:
5742 return NULL;
5743 }
5744
5745
5746 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5747 PyObject *resultobj = 0;
5748 wxPoint *arg1 = (wxPoint *) 0 ;
5749 PyObject *arg2 = (PyObject *) 0 ;
5750 bool result;
5751 void *argp1 = 0 ;
5752 int res1 = 0 ;
5753 PyObject * obj0 = 0 ;
5754 PyObject * obj1 = 0 ;
5755 char * kwnames[] = {
5756 (char *) "self",(char *) "other", NULL
5757 };
5758
5759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5761 if (!SWIG_IsOK(res1)) {
5762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5763 }
5764 arg1 = reinterpret_cast< wxPoint * >(argp1);
5765 arg2 = obj1;
5766 {
5767 result = (bool)wxPoint___ne__(arg1,arg2);
5768 if (PyErr_Occurred()) SWIG_fail;
5769 }
5770 {
5771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5772 }
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = 0;
5781 wxPoint *arg1 = (wxPoint *) 0 ;
5782 wxPoint *arg2 = 0 ;
5783 wxPoint result;
5784 void *argp1 = 0 ;
5785 int res1 = 0 ;
5786 wxPoint temp2 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "pt", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",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___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 {
5800 arg2 = &temp2;
5801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5802 }
5803 {
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 result = (arg1)->operator +((wxPoint const &)*arg2);
5806 wxPyEndAllowThreads(__tstate);
5807 if (PyErr_Occurred()) SWIG_fail;
5808 }
5809 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5810 return resultobj;
5811 fail:
5812 return NULL;
5813 }
5814
5815
5816 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5817 PyObject *resultobj = 0;
5818 wxPoint *arg1 = (wxPoint *) 0 ;
5819 wxPoint *arg2 = 0 ;
5820 wxPoint result;
5821 void *argp1 = 0 ;
5822 int res1 = 0 ;
5823 wxPoint temp2 ;
5824 PyObject * obj0 = 0 ;
5825 PyObject * obj1 = 0 ;
5826 char * kwnames[] = {
5827 (char *) "self",(char *) "pt", NULL
5828 };
5829
5830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5832 if (!SWIG_IsOK(res1)) {
5833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5834 }
5835 arg1 = reinterpret_cast< wxPoint * >(argp1);
5836 {
5837 arg2 = &temp2;
5838 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5839 }
5840 {
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 result = (arg1)->operator -((wxPoint const &)*arg2);
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj = 0;
5855 wxPoint *arg1 = (wxPoint *) 0 ;
5856 wxPoint *arg2 = 0 ;
5857 wxPoint *result = 0 ;
5858 void *argp1 = 0 ;
5859 int res1 = 0 ;
5860 wxPoint temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char * kwnames[] = {
5864 (char *) "self",(char *) "pt", NULL
5865 };
5866
5867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5869 if (!SWIG_IsOK(res1)) {
5870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5871 }
5872 arg1 = reinterpret_cast< wxPoint * >(argp1);
5873 {
5874 arg2 = &temp2;
5875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5876 }
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 {
5880 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5881 result = (wxPoint *) &_result_ref;
5882 }
5883 wxPyEndAllowThreads(__tstate);
5884 if (PyErr_Occurred()) SWIG_fail;
5885 }
5886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5887 return resultobj;
5888 fail:
5889 return NULL;
5890 }
5891
5892
5893 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5894 PyObject *resultobj = 0;
5895 wxPoint *arg1 = (wxPoint *) 0 ;
5896 wxPoint *arg2 = 0 ;
5897 wxPoint *result = 0 ;
5898 void *argp1 = 0 ;
5899 int res1 = 0 ;
5900 wxPoint temp2 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "pt", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5911 }
5912 arg1 = reinterpret_cast< wxPoint * >(argp1);
5913 {
5914 arg2 = &temp2;
5915 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5916 }
5917 {
5918 PyThreadState* __tstate = wxPyBeginAllowThreads();
5919 {
5920 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5921 result = (wxPoint *) &_result_ref;
5922 }
5923 wxPyEndAllowThreads(__tstate);
5924 if (PyErr_Occurred()) SWIG_fail;
5925 }
5926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5927 return resultobj;
5928 fail:
5929 return NULL;
5930 }
5931
5932
5933 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5934 PyObject *resultobj = 0;
5935 wxPoint *arg1 = (wxPoint *) 0 ;
5936 long arg2 ;
5937 long arg3 ;
5938 void *argp1 = 0 ;
5939 int res1 = 0 ;
5940 long val2 ;
5941 int ecode2 = 0 ;
5942 long val3 ;
5943 int ecode3 = 0 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 PyObject * obj2 = 0 ;
5947 char * kwnames[] = {
5948 (char *) "self",(char *) "x",(char *) "y", NULL
5949 };
5950
5951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5953 if (!SWIG_IsOK(res1)) {
5954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5955 }
5956 arg1 = reinterpret_cast< wxPoint * >(argp1);
5957 ecode2 = SWIG_AsVal_long(obj1, &val2);
5958 if (!SWIG_IsOK(ecode2)) {
5959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5960 }
5961 arg2 = static_cast< long >(val2);
5962 ecode3 = SWIG_AsVal_long(obj2, &val3);
5963 if (!SWIG_IsOK(ecode3)) {
5964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5965 }
5966 arg3 = static_cast< long >(val3);
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 wxPoint_Set(arg1,arg2,arg3);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_Py_Void();
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 PyObject *result = 0 ;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 PyObject *swig_obj[1] ;
5987
5988 if (!args) SWIG_fail;
5989 swig_obj[0] = args;
5990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5991 if (!SWIG_IsOK(res1)) {
5992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5993 }
5994 arg1 = reinterpret_cast< wxPoint * >(argp1);
5995 {
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 result = (PyObject *)wxPoint_Get(arg1);
5998 wxPyEndAllowThreads(__tstate);
5999 if (PyErr_Occurred()) SWIG_fail;
6000 }
6001 resultobj = result;
6002 return resultobj;
6003 fail:
6004 return NULL;
6005 }
6006
6007
6008 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6009 PyObject *obj;
6010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6011 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6012 return SWIG_Py_Void();
6013 }
6014
6015 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6016 return SWIG_Python_InitShadowInstance(args);
6017 }
6018
6019 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj = 0;
6021 int arg1 = (int) 0 ;
6022 int arg2 = (int) 0 ;
6023 int arg3 = (int) 0 ;
6024 int arg4 = (int) 0 ;
6025 wxRect *result = 0 ;
6026 int val1 ;
6027 int ecode1 = 0 ;
6028 int val2 ;
6029 int ecode2 = 0 ;
6030 int val3 ;
6031 int ecode3 = 0 ;
6032 int val4 ;
6033 int ecode4 = 0 ;
6034 PyObject * obj0 = 0 ;
6035 PyObject * obj1 = 0 ;
6036 PyObject * obj2 = 0 ;
6037 PyObject * obj3 = 0 ;
6038 char * kwnames[] = {
6039 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6040 };
6041
6042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6043 if (obj0) {
6044 ecode1 = SWIG_AsVal_int(obj0, &val1);
6045 if (!SWIG_IsOK(ecode1)) {
6046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6047 }
6048 arg1 = static_cast< int >(val1);
6049 }
6050 if (obj1) {
6051 ecode2 = SWIG_AsVal_int(obj1, &val2);
6052 if (!SWIG_IsOK(ecode2)) {
6053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6054 }
6055 arg2 = static_cast< int >(val2);
6056 }
6057 if (obj2) {
6058 ecode3 = SWIG_AsVal_int(obj2, &val3);
6059 if (!SWIG_IsOK(ecode3)) {
6060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6061 }
6062 arg3 = static_cast< int >(val3);
6063 }
6064 if (obj3) {
6065 ecode4 = SWIG_AsVal_int(obj3, &val4);
6066 if (!SWIG_IsOK(ecode4)) {
6067 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6068 }
6069 arg4 = static_cast< int >(val4);
6070 }
6071 {
6072 PyThreadState* __tstate = wxPyBeginAllowThreads();
6073 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6074 wxPyEndAllowThreads(__tstate);
6075 if (PyErr_Occurred()) SWIG_fail;
6076 }
6077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6078 return resultobj;
6079 fail:
6080 return NULL;
6081 }
6082
6083
6084 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6085 PyObject *resultobj = 0;
6086 wxPoint *arg1 = 0 ;
6087 wxPoint *arg2 = 0 ;
6088 wxRect *result = 0 ;
6089 wxPoint temp1 ;
6090 wxPoint temp2 ;
6091 PyObject * obj0 = 0 ;
6092 PyObject * obj1 = 0 ;
6093 char * kwnames[] = {
6094 (char *) "topLeft",(char *) "bottomRight", NULL
6095 };
6096
6097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6098 {
6099 arg1 = &temp1;
6100 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6101 }
6102 {
6103 arg2 = &temp2;
6104 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6105 }
6106 {
6107 PyThreadState* __tstate = wxPyBeginAllowThreads();
6108 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6109 wxPyEndAllowThreads(__tstate);
6110 if (PyErr_Occurred()) SWIG_fail;
6111 }
6112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6113 return resultobj;
6114 fail:
6115 return NULL;
6116 }
6117
6118
6119 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6120 PyObject *resultobj = 0;
6121 wxPoint *arg1 = 0 ;
6122 wxSize *arg2 = 0 ;
6123 wxRect *result = 0 ;
6124 wxPoint temp1 ;
6125 wxSize temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char * kwnames[] = {
6129 (char *) "pos",(char *) "size", NULL
6130 };
6131
6132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6133 {
6134 arg1 = &temp1;
6135 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6136 }
6137 {
6138 arg2 = &temp2;
6139 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6140 }
6141 {
6142 PyThreadState* __tstate = wxPyBeginAllowThreads();
6143 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj = 0;
6156 wxSize *arg1 = 0 ;
6157 wxRect *result = 0 ;
6158 wxSize temp1 ;
6159 PyObject * obj0 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "size", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6172 wxPyEndAllowThreads(__tstate);
6173 if (PyErr_Occurred()) SWIG_fail;
6174 }
6175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6183 PyObject *resultobj = 0;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 void *argp1 = 0 ;
6186 int res1 = 0 ;
6187 PyObject *swig_obj[1] ;
6188
6189 if (!args) SWIG_fail;
6190 swig_obj[0] = args;
6191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6192 if (!SWIG_IsOK(res1)) {
6193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6194 }
6195 arg1 = reinterpret_cast< wxRect * >(argp1);
6196 {
6197 PyThreadState* __tstate = wxPyBeginAllowThreads();
6198 delete arg1;
6199
6200 wxPyEndAllowThreads(__tstate);
6201 if (PyErr_Occurred()) SWIG_fail;
6202 }
6203 resultobj = SWIG_Py_Void();
6204 return resultobj;
6205 fail:
6206 return NULL;
6207 }
6208
6209
6210 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6211 PyObject *resultobj = 0;
6212 wxRect *arg1 = (wxRect *) 0 ;
6213 int result;
6214 void *argp1 = 0 ;
6215 int res1 = 0 ;
6216 PyObject *swig_obj[1] ;
6217
6218 if (!args) SWIG_fail;
6219 swig_obj[0] = args;
6220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6221 if (!SWIG_IsOK(res1)) {
6222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6223 }
6224 arg1 = reinterpret_cast< wxRect * >(argp1);
6225 {
6226 PyThreadState* __tstate = wxPyBeginAllowThreads();
6227 result = (int)((wxRect const *)arg1)->GetX();
6228 wxPyEndAllowThreads(__tstate);
6229 if (PyErr_Occurred()) SWIG_fail;
6230 }
6231 resultobj = SWIG_From_int(static_cast< int >(result));
6232 return resultobj;
6233 fail:
6234 return NULL;
6235 }
6236
6237
6238 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6239 PyObject *resultobj = 0;
6240 wxRect *arg1 = (wxRect *) 0 ;
6241 int arg2 ;
6242 void *argp1 = 0 ;
6243 int res1 = 0 ;
6244 int val2 ;
6245 int ecode2 = 0 ;
6246 PyObject * obj0 = 0 ;
6247 PyObject * obj1 = 0 ;
6248 char * kwnames[] = {
6249 (char *) "self",(char *) "x", NULL
6250 };
6251
6252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6256 }
6257 arg1 = reinterpret_cast< wxRect * >(argp1);
6258 ecode2 = SWIG_AsVal_int(obj1, &val2);
6259 if (!SWIG_IsOK(ecode2)) {
6260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6261 }
6262 arg2 = static_cast< int >(val2);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 (arg1)->SetX(arg2);
6266 wxPyEndAllowThreads(__tstate);
6267 if (PyErr_Occurred()) SWIG_fail;
6268 }
6269 resultobj = SWIG_Py_Void();
6270 return resultobj;
6271 fail:
6272 return NULL;
6273 }
6274
6275
6276 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6277 PyObject *resultobj = 0;
6278 wxRect *arg1 = (wxRect *) 0 ;
6279 int result;
6280 void *argp1 = 0 ;
6281 int res1 = 0 ;
6282 PyObject *swig_obj[1] ;
6283
6284 if (!args) SWIG_fail;
6285 swig_obj[0] = args;
6286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6287 if (!SWIG_IsOK(res1)) {
6288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6289 }
6290 arg1 = reinterpret_cast< wxRect * >(argp1);
6291 {
6292 PyThreadState* __tstate = wxPyBeginAllowThreads();
6293 result = (int)(arg1)->GetY();
6294 wxPyEndAllowThreads(__tstate);
6295 if (PyErr_Occurred()) SWIG_fail;
6296 }
6297 resultobj = SWIG_From_int(static_cast< int >(result));
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int arg2 ;
6308 void *argp1 = 0 ;
6309 int res1 = 0 ;
6310 int val2 ;
6311 int ecode2 = 0 ;
6312 PyObject * obj0 = 0 ;
6313 PyObject * obj1 = 0 ;
6314 char * kwnames[] = {
6315 (char *) "self",(char *) "y", NULL
6316 };
6317
6318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6320 if (!SWIG_IsOK(res1)) {
6321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6322 }
6323 arg1 = reinterpret_cast< wxRect * >(argp1);
6324 ecode2 = SWIG_AsVal_int(obj1, &val2);
6325 if (!SWIG_IsOK(ecode2)) {
6326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6327 }
6328 arg2 = static_cast< int >(val2);
6329 {
6330 PyThreadState* __tstate = wxPyBeginAllowThreads();
6331 (arg1)->SetY(arg2);
6332 wxPyEndAllowThreads(__tstate);
6333 if (PyErr_Occurred()) SWIG_fail;
6334 }
6335 resultobj = SWIG_Py_Void();
6336 return resultobj;
6337 fail:
6338 return NULL;
6339 }
6340
6341
6342 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6343 PyObject *resultobj = 0;
6344 wxRect *arg1 = (wxRect *) 0 ;
6345 int result;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 PyObject *swig_obj[1] ;
6349
6350 if (!args) SWIG_fail;
6351 swig_obj[0] = args;
6352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6355 }
6356 arg1 = reinterpret_cast< wxRect * >(argp1);
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 result = (int)((wxRect const *)arg1)->GetWidth();
6360 wxPyEndAllowThreads(__tstate);
6361 if (PyErr_Occurred()) SWIG_fail;
6362 }
6363 resultobj = SWIG_From_int(static_cast< int >(result));
6364 return resultobj;
6365 fail:
6366 return NULL;
6367 }
6368
6369
6370 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6371 PyObject *resultobj = 0;
6372 wxRect *arg1 = (wxRect *) 0 ;
6373 int arg2 ;
6374 void *argp1 = 0 ;
6375 int res1 = 0 ;
6376 int val2 ;
6377 int ecode2 = 0 ;
6378 PyObject * obj0 = 0 ;
6379 PyObject * obj1 = 0 ;
6380 char * kwnames[] = {
6381 (char *) "self",(char *) "w", NULL
6382 };
6383
6384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6386 if (!SWIG_IsOK(res1)) {
6387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6388 }
6389 arg1 = reinterpret_cast< wxRect * >(argp1);
6390 ecode2 = SWIG_AsVal_int(obj1, &val2);
6391 if (!SWIG_IsOK(ecode2)) {
6392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6393 }
6394 arg2 = static_cast< int >(val2);
6395 {
6396 PyThreadState* __tstate = wxPyBeginAllowThreads();
6397 (arg1)->SetWidth(arg2);
6398 wxPyEndAllowThreads(__tstate);
6399 if (PyErr_Occurred()) SWIG_fail;
6400 }
6401 resultobj = SWIG_Py_Void();
6402 return resultobj;
6403 fail:
6404 return NULL;
6405 }
6406
6407
6408 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6409 PyObject *resultobj = 0;
6410 wxRect *arg1 = (wxRect *) 0 ;
6411 int result;
6412 void *argp1 = 0 ;
6413 int res1 = 0 ;
6414 PyObject *swig_obj[1] ;
6415
6416 if (!args) SWIG_fail;
6417 swig_obj[0] = args;
6418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6419 if (!SWIG_IsOK(res1)) {
6420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6421 }
6422 arg1 = reinterpret_cast< wxRect * >(argp1);
6423 {
6424 PyThreadState* __tstate = wxPyBeginAllowThreads();
6425 result = (int)((wxRect const *)arg1)->GetHeight();
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 resultobj = SWIG_From_int(static_cast< int >(result));
6430 return resultobj;
6431 fail:
6432 return NULL;
6433 }
6434
6435
6436 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6437 PyObject *resultobj = 0;
6438 wxRect *arg1 = (wxRect *) 0 ;
6439 int arg2 ;
6440 void *argp1 = 0 ;
6441 int res1 = 0 ;
6442 int val2 ;
6443 int ecode2 = 0 ;
6444 PyObject * obj0 = 0 ;
6445 PyObject * obj1 = 0 ;
6446 char * kwnames[] = {
6447 (char *) "self",(char *) "h", NULL
6448 };
6449
6450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6452 if (!SWIG_IsOK(res1)) {
6453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6454 }
6455 arg1 = reinterpret_cast< wxRect * >(argp1);
6456 ecode2 = SWIG_AsVal_int(obj1, &val2);
6457 if (!SWIG_IsOK(ecode2)) {
6458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6459 }
6460 arg2 = static_cast< int >(val2);
6461 {
6462 PyThreadState* __tstate = wxPyBeginAllowThreads();
6463 (arg1)->SetHeight(arg2);
6464 wxPyEndAllowThreads(__tstate);
6465 if (PyErr_Occurred()) SWIG_fail;
6466 }
6467 resultobj = SWIG_Py_Void();
6468 return resultobj;
6469 fail:
6470 return NULL;
6471 }
6472
6473
6474 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6475 PyObject *resultobj = 0;
6476 wxRect *arg1 = (wxRect *) 0 ;
6477 wxPoint result;
6478 void *argp1 = 0 ;
6479 int res1 = 0 ;
6480 PyObject *swig_obj[1] ;
6481
6482 if (!args) SWIG_fail;
6483 swig_obj[0] = args;
6484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6485 if (!SWIG_IsOK(res1)) {
6486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6487 }
6488 arg1 = reinterpret_cast< wxRect * >(argp1);
6489 {
6490 PyThreadState* __tstate = wxPyBeginAllowThreads();
6491 result = ((wxRect const *)arg1)->GetPosition();
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj = 0;
6504 wxRect *arg1 = (wxRect *) 0 ;
6505 wxPoint *arg2 = 0 ;
6506 void *argp1 = 0 ;
6507 int res1 = 0 ;
6508 wxPoint temp2 ;
6509 PyObject * obj0 = 0 ;
6510 PyObject * obj1 = 0 ;
6511 char * kwnames[] = {
6512 (char *) "self",(char *) "p", NULL
6513 };
6514
6515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 arg2 = &temp2;
6523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6524 }
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 (arg1)->SetPosition((wxPoint const &)*arg2);
6528 wxPyEndAllowThreads(__tstate);
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_Py_Void();
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 wxSize result;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 PyObject *swig_obj[1] ;
6545
6546 if (!args) SWIG_fail;
6547 swig_obj[0] = args;
6548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6549 if (!SWIG_IsOK(res1)) {
6550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6551 }
6552 arg1 = reinterpret_cast< wxRect * >(argp1);
6553 {
6554 PyThreadState* __tstate = wxPyBeginAllowThreads();
6555 result = ((wxRect const *)arg1)->GetSize();
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6560 return resultobj;
6561 fail:
6562 return NULL;
6563 }
6564
6565
6566 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6567 PyObject *resultobj = 0;
6568 wxRect *arg1 = (wxRect *) 0 ;
6569 wxSize *arg2 = 0 ;
6570 void *argp1 = 0 ;
6571 int res1 = 0 ;
6572 wxSize temp2 ;
6573 PyObject * obj0 = 0 ;
6574 PyObject * obj1 = 0 ;
6575 char * kwnames[] = {
6576 (char *) "self",(char *) "s", NULL
6577 };
6578
6579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 arg2 = &temp2;
6587 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6588 }
6589 {
6590 PyThreadState* __tstate = wxPyBeginAllowThreads();
6591 (arg1)->SetSize((wxSize const &)*arg2);
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = SWIG_Py_Void();
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6603 PyObject *resultobj = 0;
6604 wxRect *arg1 = (wxRect *) 0 ;
6605 bool result;
6606 void *argp1 = 0 ;
6607 int res1 = 0 ;
6608 PyObject *swig_obj[1] ;
6609
6610 if (!args) SWIG_fail;
6611 swig_obj[0] = args;
6612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6615 }
6616 arg1 = reinterpret_cast< wxRect * >(argp1);
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (bool)((wxRect const *)arg1)->IsEmpty();
6620 wxPyEndAllowThreads(__tstate);
6621 if (PyErr_Occurred()) SWIG_fail;
6622 }
6623 {
6624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6625 }
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 wxPoint result;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 PyObject *swig_obj[1] ;
6639
6640 if (!args) SWIG_fail;
6641 swig_obj[0] = args;
6642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6643 if (!SWIG_IsOK(res1)) {
6644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 PyThreadState* __tstate = wxPyBeginAllowThreads();
6649 result = ((wxRect const *)arg1)->GetTopLeft();
6650 wxPyEndAllowThreads(__tstate);
6651 if (PyErr_Occurred()) SWIG_fail;
6652 }
6653 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6654 return resultobj;
6655 fail:
6656 return NULL;
6657 }
6658
6659
6660 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6661 PyObject *resultobj = 0;
6662 wxRect *arg1 = (wxRect *) 0 ;
6663 wxPoint *arg2 = 0 ;
6664 void *argp1 = 0 ;
6665 int res1 = 0 ;
6666 wxPoint temp2 ;
6667 PyObject * obj0 = 0 ;
6668 PyObject * obj1 = 0 ;
6669 char * kwnames[] = {
6670 (char *) "self",(char *) "p", NULL
6671 };
6672
6673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6675 if (!SWIG_IsOK(res1)) {
6676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6677 }
6678 arg1 = reinterpret_cast< wxRect * >(argp1);
6679 {
6680 arg2 = &temp2;
6681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6682 }
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6686 wxPyEndAllowThreads(__tstate);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxPoint result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 result = ((wxRect const *)arg1)->GetBottomRight();
6714 wxPyEndAllowThreads(__tstate);
6715 if (PyErr_Occurred()) SWIG_fail;
6716 }
6717 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6718 return resultobj;
6719 fail:
6720 return NULL;
6721 }
6722
6723
6724 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6725 PyObject *resultobj = 0;
6726 wxRect *arg1 = (wxRect *) 0 ;
6727 wxPoint *arg2 = 0 ;
6728 void *argp1 = 0 ;
6729 int res1 = 0 ;
6730 wxPoint temp2 ;
6731 PyObject * obj0 = 0 ;
6732 PyObject * obj1 = 0 ;
6733 char * kwnames[] = {
6734 (char *) "self",(char *) "p", NULL
6735 };
6736
6737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6739 if (!SWIG_IsOK(res1)) {
6740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6741 }
6742 arg1 = reinterpret_cast< wxRect * >(argp1);
6743 {
6744 arg2 = &temp2;
6745 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6746 }
6747 {
6748 PyThreadState* __tstate = wxPyBeginAllowThreads();
6749 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6750 wxPyEndAllowThreads(__tstate);
6751 if (PyErr_Occurred()) SWIG_fail;
6752 }
6753 resultobj = SWIG_Py_Void();
6754 return resultobj;
6755 fail:
6756 return NULL;
6757 }
6758
6759
6760 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6761 PyObject *resultobj = 0;
6762 wxRect *arg1 = (wxRect *) 0 ;
6763 int result;
6764 void *argp1 = 0 ;
6765 int res1 = 0 ;
6766 PyObject *swig_obj[1] ;
6767
6768 if (!args) SWIG_fail;
6769 swig_obj[0] = args;
6770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6771 if (!SWIG_IsOK(res1)) {
6772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6773 }
6774 arg1 = reinterpret_cast< wxRect * >(argp1);
6775 {
6776 PyThreadState* __tstate = wxPyBeginAllowThreads();
6777 result = (int)((wxRect const *)arg1)->GetLeft();
6778 wxPyEndAllowThreads(__tstate);
6779 if (PyErr_Occurred()) SWIG_fail;
6780 }
6781 resultobj = SWIG_From_int(static_cast< int >(result));
6782 return resultobj;
6783 fail:
6784 return NULL;
6785 }
6786
6787
6788 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6789 PyObject *resultobj = 0;
6790 wxRect *arg1 = (wxRect *) 0 ;
6791 int result;
6792 void *argp1 = 0 ;
6793 int res1 = 0 ;
6794 PyObject *swig_obj[1] ;
6795
6796 if (!args) SWIG_fail;
6797 swig_obj[0] = args;
6798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6799 if (!SWIG_IsOK(res1)) {
6800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6801 }
6802 arg1 = reinterpret_cast< wxRect * >(argp1);
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 result = (int)((wxRect const *)arg1)->GetTop();
6806 wxPyEndAllowThreads(__tstate);
6807 if (PyErr_Occurred()) SWIG_fail;
6808 }
6809 resultobj = SWIG_From_int(static_cast< int >(result));
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6817 PyObject *resultobj = 0;
6818 wxRect *arg1 = (wxRect *) 0 ;
6819 int result;
6820 void *argp1 = 0 ;
6821 int res1 = 0 ;
6822 PyObject *swig_obj[1] ;
6823
6824 if (!args) SWIG_fail;
6825 swig_obj[0] = args;
6826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6827 if (!SWIG_IsOK(res1)) {
6828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6829 }
6830 arg1 = reinterpret_cast< wxRect * >(argp1);
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 result = (int)((wxRect const *)arg1)->GetBottom();
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_From_int(static_cast< int >(result));
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 int result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = (int)((wxRect const *)arg1)->GetRight();
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_From_int(static_cast< int >(result));
6866 return resultobj;
6867 fail:
6868 return NULL;
6869 }
6870
6871
6872 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj = 0;
6874 wxRect *arg1 = (wxRect *) 0 ;
6875 int arg2 ;
6876 void *argp1 = 0 ;
6877 int res1 = 0 ;
6878 int val2 ;
6879 int ecode2 = 0 ;
6880 PyObject * obj0 = 0 ;
6881 PyObject * obj1 = 0 ;
6882 char * kwnames[] = {
6883 (char *) "self",(char *) "left", NULL
6884 };
6885
6886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6888 if (!SWIG_IsOK(res1)) {
6889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6890 }
6891 arg1 = reinterpret_cast< wxRect * >(argp1);
6892 ecode2 = SWIG_AsVal_int(obj1, &val2);
6893 if (!SWIG_IsOK(ecode2)) {
6894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6895 }
6896 arg2 = static_cast< int >(val2);
6897 {
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 (arg1)->SetLeft(arg2);
6900 wxPyEndAllowThreads(__tstate);
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 resultobj = SWIG_Py_Void();
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj = 0;
6912 wxRect *arg1 = (wxRect *) 0 ;
6913 int arg2 ;
6914 void *argp1 = 0 ;
6915 int res1 = 0 ;
6916 int val2 ;
6917 int ecode2 = 0 ;
6918 PyObject * obj0 = 0 ;
6919 PyObject * obj1 = 0 ;
6920 char * kwnames[] = {
6921 (char *) "self",(char *) "right", NULL
6922 };
6923
6924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6926 if (!SWIG_IsOK(res1)) {
6927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6928 }
6929 arg1 = reinterpret_cast< wxRect * >(argp1);
6930 ecode2 = SWIG_AsVal_int(obj1, &val2);
6931 if (!SWIG_IsOK(ecode2)) {
6932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6933 }
6934 arg2 = static_cast< int >(val2);
6935 {
6936 PyThreadState* __tstate = wxPyBeginAllowThreads();
6937 (arg1)->SetRight(arg2);
6938 wxPyEndAllowThreads(__tstate);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_Py_Void();
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6949 PyObject *resultobj = 0;
6950 wxRect *arg1 = (wxRect *) 0 ;
6951 int arg2 ;
6952 void *argp1 = 0 ;
6953 int res1 = 0 ;
6954 int val2 ;
6955 int ecode2 = 0 ;
6956 PyObject * obj0 = 0 ;
6957 PyObject * obj1 = 0 ;
6958 char * kwnames[] = {
6959 (char *) "self",(char *) "top", NULL
6960 };
6961
6962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6964 if (!SWIG_IsOK(res1)) {
6965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6966 }
6967 arg1 = reinterpret_cast< wxRect * >(argp1);
6968 ecode2 = SWIG_AsVal_int(obj1, &val2);
6969 if (!SWIG_IsOK(ecode2)) {
6970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6971 }
6972 arg2 = static_cast< int >(val2);
6973 {
6974 PyThreadState* __tstate = wxPyBeginAllowThreads();
6975 (arg1)->SetTop(arg2);
6976 wxPyEndAllowThreads(__tstate);
6977 if (PyErr_Occurred()) SWIG_fail;
6978 }
6979 resultobj = SWIG_Py_Void();
6980 return resultobj;
6981 fail:
6982 return NULL;
6983 }
6984
6985
6986 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6987 PyObject *resultobj = 0;
6988 wxRect *arg1 = (wxRect *) 0 ;
6989 int arg2 ;
6990 void *argp1 = 0 ;
6991 int res1 = 0 ;
6992 int val2 ;
6993 int ecode2 = 0 ;
6994 PyObject * obj0 = 0 ;
6995 PyObject * obj1 = 0 ;
6996 char * kwnames[] = {
6997 (char *) "self",(char *) "bottom", NULL
6998 };
6999
7000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7002 if (!SWIG_IsOK(res1)) {
7003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7004 }
7005 arg1 = reinterpret_cast< wxRect * >(argp1);
7006 ecode2 = SWIG_AsVal_int(obj1, &val2);
7007 if (!SWIG_IsOK(ecode2)) {
7008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7009 }
7010 arg2 = static_cast< int >(val2);
7011 {
7012 PyThreadState* __tstate = wxPyBeginAllowThreads();
7013 (arg1)->SetBottom(arg2);
7014 wxPyEndAllowThreads(__tstate);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int arg2 ;
7028 int arg3 ;
7029 wxRect *result = 0 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 int val2 ;
7033 int ecode2 = 0 ;
7034 int val3 ;
7035 int ecode3 = 0 ;
7036 PyObject * obj0 = 0 ;
7037 PyObject * obj1 = 0 ;
7038 PyObject * obj2 = 0 ;
7039 char * kwnames[] = {
7040 (char *) "self",(char *) "dx",(char *) "dy", NULL
7041 };
7042
7043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 ecode2 = SWIG_AsVal_int(obj1, &val2);
7050 if (!SWIG_IsOK(ecode2)) {
7051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7052 }
7053 arg2 = static_cast< int >(val2);
7054 ecode3 = SWIG_AsVal_int(obj2, &val3);
7055 if (!SWIG_IsOK(ecode3)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7057 }
7058 arg3 = static_cast< int >(val3);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 {
7062 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7063 result = (wxRect *) &_result_ref;
7064 }
7065 wxPyEndAllowThreads(__tstate);
7066 if (PyErr_Occurred()) SWIG_fail;
7067 }
7068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7069 return resultobj;
7070 fail:
7071 return NULL;
7072 }
7073
7074
7075 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj = 0;
7077 wxRect *arg1 = (wxRect *) 0 ;
7078 int arg2 ;
7079 int arg3 ;
7080 wxRect *result = 0 ;
7081 void *argp1 = 0 ;
7082 int res1 = 0 ;
7083 int val2 ;
7084 int ecode2 = 0 ;
7085 int val3 ;
7086 int ecode3 = 0 ;
7087 PyObject * obj0 = 0 ;
7088 PyObject * obj1 = 0 ;
7089 PyObject * obj2 = 0 ;
7090 char * kwnames[] = {
7091 (char *) "self",(char *) "dx",(char *) "dy", NULL
7092 };
7093
7094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7096 if (!SWIG_IsOK(res1)) {
7097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7098 }
7099 arg1 = reinterpret_cast< wxRect * >(argp1);
7100 ecode2 = SWIG_AsVal_int(obj1, &val2);
7101 if (!SWIG_IsOK(ecode2)) {
7102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7103 }
7104 arg2 = static_cast< int >(val2);
7105 ecode3 = SWIG_AsVal_int(obj2, &val3);
7106 if (!SWIG_IsOK(ecode3)) {
7107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7108 }
7109 arg3 = static_cast< int >(val3);
7110 {
7111 PyThreadState* __tstate = wxPyBeginAllowThreads();
7112 {
7113 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7114 result = (wxRect *) &_result_ref;
7115 }
7116 wxPyEndAllowThreads(__tstate);
7117 if (PyErr_Occurred()) SWIG_fail;
7118 }
7119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7120 return resultobj;
7121 fail:
7122 return NULL;
7123 }
7124
7125
7126 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7127 PyObject *resultobj = 0;
7128 wxRect *arg1 = (wxRect *) 0 ;
7129 int arg2 ;
7130 int arg3 ;
7131 void *argp1 = 0 ;
7132 int res1 = 0 ;
7133 int val2 ;
7134 int ecode2 = 0 ;
7135 int val3 ;
7136 int ecode3 = 0 ;
7137 PyObject * obj0 = 0 ;
7138 PyObject * obj1 = 0 ;
7139 PyObject * obj2 = 0 ;
7140 char * kwnames[] = {
7141 (char *) "self",(char *) "dx",(char *) "dy", NULL
7142 };
7143
7144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7146 if (!SWIG_IsOK(res1)) {
7147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7148 }
7149 arg1 = reinterpret_cast< wxRect * >(argp1);
7150 ecode2 = SWIG_AsVal_int(obj1, &val2);
7151 if (!SWIG_IsOK(ecode2)) {
7152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7153 }
7154 arg2 = static_cast< int >(val2);
7155 ecode3 = SWIG_AsVal_int(obj2, &val3);
7156 if (!SWIG_IsOK(ecode3)) {
7157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7158 }
7159 arg3 = static_cast< int >(val3);
7160 {
7161 PyThreadState* __tstate = wxPyBeginAllowThreads();
7162 (arg1)->Offset(arg2,arg3);
7163 wxPyEndAllowThreads(__tstate);
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_Py_Void();
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7174 PyObject *resultobj = 0;
7175 wxRect *arg1 = (wxRect *) 0 ;
7176 wxPoint *arg2 = 0 ;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 wxPoint temp2 ;
7180 PyObject * obj0 = 0 ;
7181 PyObject * obj1 = 0 ;
7182 char * kwnames[] = {
7183 (char *) "self",(char *) "pt", NULL
7184 };
7185
7186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7188 if (!SWIG_IsOK(res1)) {
7189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7190 }
7191 arg1 = reinterpret_cast< wxRect * >(argp1);
7192 {
7193 arg2 = &temp2;
7194 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7195 }
7196 {
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 (arg1)->Offset((wxPoint const &)*arg2);
7199 wxPyEndAllowThreads(__tstate);
7200 if (PyErr_Occurred()) SWIG_fail;
7201 }
7202 resultobj = SWIG_Py_Void();
7203 return resultobj;
7204 fail:
7205 return NULL;
7206 }
7207
7208
7209 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7210 PyObject *resultobj = 0;
7211 wxRect *arg1 = (wxRect *) 0 ;
7212 wxRect *arg2 = 0 ;
7213 wxRect result;
7214 void *argp1 = 0 ;
7215 int res1 = 0 ;
7216 wxRect temp2 ;
7217 PyObject * obj0 = 0 ;
7218 PyObject * obj1 = 0 ;
7219 char * kwnames[] = {
7220 (char *) "self",(char *) "rect", NULL
7221 };
7222
7223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7225 if (!SWIG_IsOK(res1)) {
7226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7227 }
7228 arg1 = reinterpret_cast< wxRect * >(argp1);
7229 {
7230 arg2 = &temp2;
7231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7232 }
7233 {
7234 PyThreadState* __tstate = wxPyBeginAllowThreads();
7235 result = (arg1)->Intersect((wxRect const &)*arg2);
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj = 0;
7248 wxRect *arg1 = (wxRect *) 0 ;
7249 wxRect *arg2 = 0 ;
7250 wxRect result;
7251 void *argp1 = 0 ;
7252 int res1 = 0 ;
7253 wxRect temp2 ;
7254 PyObject * obj0 = 0 ;
7255 PyObject * obj1 = 0 ;
7256 char * kwnames[] = {
7257 (char *) "self",(char *) "rect", NULL
7258 };
7259
7260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7262 if (!SWIG_IsOK(res1)) {
7263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7264 }
7265 arg1 = reinterpret_cast< wxRect * >(argp1);
7266 {
7267 arg2 = &temp2;
7268 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7269 }
7270 {
7271 PyThreadState* __tstate = wxPyBeginAllowThreads();
7272 result = (arg1)->Union((wxRect const &)*arg2);
7273 wxPyEndAllowThreads(__tstate);
7274 if (PyErr_Occurred()) SWIG_fail;
7275 }
7276 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7277 return resultobj;
7278 fail:
7279 return NULL;
7280 }
7281
7282
7283 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7284 PyObject *resultobj = 0;
7285 wxRect *arg1 = (wxRect *) 0 ;
7286 wxRect *arg2 = 0 ;
7287 wxRect result;
7288 void *argp1 = 0 ;
7289 int res1 = 0 ;
7290 wxRect temp2 ;
7291 PyObject * obj0 = 0 ;
7292 PyObject * obj1 = 0 ;
7293 char * kwnames[] = {
7294 (char *) "self",(char *) "rect", NULL
7295 };
7296
7297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7299 if (!SWIG_IsOK(res1)) {
7300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7301 }
7302 arg1 = reinterpret_cast< wxRect * >(argp1);
7303 {
7304 arg2 = &temp2;
7305 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7306 }
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7310 wxPyEndAllowThreads(__tstate);
7311 if (PyErr_Occurred()) SWIG_fail;
7312 }
7313 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 wxRect *arg2 = 0 ;
7324 wxRect *result = 0 ;
7325 void *argp1 = 0 ;
7326 int res1 = 0 ;
7327 wxRect temp2 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 char * kwnames[] = {
7331 (char *) "self",(char *) "rect", NULL
7332 };
7333
7334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7336 if (!SWIG_IsOK(res1)) {
7337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7338 }
7339 arg1 = reinterpret_cast< wxRect * >(argp1);
7340 {
7341 arg2 = &temp2;
7342 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7343 }
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 {
7347 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7348 result = (wxRect *) &_result_ref;
7349 }
7350 wxPyEndAllowThreads(__tstate);
7351 if (PyErr_Occurred()) SWIG_fail;
7352 }
7353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7354 return resultobj;
7355 fail:
7356 return NULL;
7357 }
7358
7359
7360 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7361 PyObject *resultobj = 0;
7362 wxRect *arg1 = (wxRect *) 0 ;
7363 PyObject *arg2 = (PyObject *) 0 ;
7364 bool result;
7365 void *argp1 = 0 ;
7366 int res1 = 0 ;
7367 PyObject * obj0 = 0 ;
7368 PyObject * obj1 = 0 ;
7369 char * kwnames[] = {
7370 (char *) "self",(char *) "other", NULL
7371 };
7372
7373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7375 if (!SWIG_IsOK(res1)) {
7376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7377 }
7378 arg1 = reinterpret_cast< wxRect * >(argp1);
7379 arg2 = obj1;
7380 {
7381 result = (bool)wxRect___eq__(arg1,arg2);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 {
7385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7386 }
7387 return resultobj;
7388 fail:
7389 return NULL;
7390 }
7391
7392
7393 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7394 PyObject *resultobj = 0;
7395 wxRect *arg1 = (wxRect *) 0 ;
7396 PyObject *arg2 = (PyObject *) 0 ;
7397 bool result;
7398 void *argp1 = 0 ;
7399 int res1 = 0 ;
7400 PyObject * obj0 = 0 ;
7401 PyObject * obj1 = 0 ;
7402 char * kwnames[] = {
7403 (char *) "self",(char *) "other", NULL
7404 };
7405
7406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7408 if (!SWIG_IsOK(res1)) {
7409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7410 }
7411 arg1 = reinterpret_cast< wxRect * >(argp1);
7412 arg2 = obj1;
7413 {
7414 result = (bool)wxRect___ne__(arg1,arg2);
7415 if (PyErr_Occurred()) SWIG_fail;
7416 }
7417 {
7418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7419 }
7420 return resultobj;
7421 fail:
7422 return NULL;
7423 }
7424
7425
7426 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7427 PyObject *resultobj = 0;
7428 wxRect *arg1 = (wxRect *) 0 ;
7429 int arg2 ;
7430 int arg3 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 int val2 ;
7435 int ecode2 = 0 ;
7436 int val3 ;
7437 int ecode3 = 0 ;
7438 PyObject * obj0 = 0 ;
7439 PyObject * obj1 = 0 ;
7440 PyObject * obj2 = 0 ;
7441 char * kwnames[] = {
7442 (char *) "self",(char *) "x",(char *) "y", NULL
7443 };
7444
7445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7449 }
7450 arg1 = reinterpret_cast< wxRect * >(argp1);
7451 ecode2 = SWIG_AsVal_int(obj1, &val2);
7452 if (!SWIG_IsOK(ecode2)) {
7453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7454 }
7455 arg2 = static_cast< int >(val2);
7456 ecode3 = SWIG_AsVal_int(obj2, &val3);
7457 if (!SWIG_IsOK(ecode3)) {
7458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7459 }
7460 arg3 = static_cast< int >(val3);
7461 {
7462 PyThreadState* __tstate = wxPyBeginAllowThreads();
7463 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7464 wxPyEndAllowThreads(__tstate);
7465 if (PyErr_Occurred()) SWIG_fail;
7466 }
7467 {
7468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7469 }
7470 return resultobj;
7471 fail:
7472 return NULL;
7473 }
7474
7475
7476 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7477 PyObject *resultobj = 0;
7478 wxRect *arg1 = (wxRect *) 0 ;
7479 wxPoint *arg2 = 0 ;
7480 bool result;
7481 void *argp1 = 0 ;
7482 int res1 = 0 ;
7483 wxPoint temp2 ;
7484 PyObject * obj0 = 0 ;
7485 PyObject * obj1 = 0 ;
7486 char * kwnames[] = {
7487 (char *) "self",(char *) "pt", NULL
7488 };
7489
7490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7492 if (!SWIG_IsOK(res1)) {
7493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7494 }
7495 arg1 = reinterpret_cast< wxRect * >(argp1);
7496 {
7497 arg2 = &temp2;
7498 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7499 }
7500 {
7501 PyThreadState* __tstate = wxPyBeginAllowThreads();
7502 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7503 wxPyEndAllowThreads(__tstate);
7504 if (PyErr_Occurred()) SWIG_fail;
7505 }
7506 {
7507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7508 }
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj = 0;
7517 wxRect *arg1 = (wxRect *) 0 ;
7518 wxRect *arg2 = 0 ;
7519 bool result;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 wxRect temp2 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char * kwnames[] = {
7526 (char *) "self",(char *) "rect", NULL
7527 };
7528
7529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7533 }
7534 arg1 = reinterpret_cast< wxRect * >(argp1);
7535 {
7536 arg2 = &temp2;
7537 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7538 }
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7542 wxPyEndAllowThreads(__tstate);
7543 if (PyErr_Occurred()) SWIG_fail;
7544 }
7545 {
7546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7547 }
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 int arg3 = (int) wxBOTH ;
7559 wxRect result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 wxRect temp2 ;
7563 int val3 ;
7564 int ecode3 = 0 ;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 PyObject * obj2 = 0 ;
7568 char * kwnames[] = {
7569 (char *) "self",(char *) "r",(char *) "dir", NULL
7570 };
7571
7572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7574 if (!SWIG_IsOK(res1)) {
7575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7576 }
7577 arg1 = reinterpret_cast< wxRect * >(argp1);
7578 {
7579 arg2 = &temp2;
7580 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7581 }
7582 if (obj2) {
7583 ecode3 = SWIG_AsVal_int(obj2, &val3);
7584 if (!SWIG_IsOK(ecode3)) {
7585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7586 }
7587 arg3 = static_cast< int >(val3);
7588 }
7589 {
7590 PyThreadState* __tstate = wxPyBeginAllowThreads();
7591 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7592 wxPyEndAllowThreads(__tstate);
7593 if (PyErr_Occurred()) SWIG_fail;
7594 }
7595 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 int arg2 ;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 int val2 ;
7609 int ecode2 = 0 ;
7610 PyObject *swig_obj[2] ;
7611
7612 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7616 }
7617 arg1 = reinterpret_cast< wxRect * >(argp1);
7618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7619 if (!SWIG_IsOK(ecode2)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7621 }
7622 arg2 = static_cast< int >(val2);
7623 if (arg1) (arg1)->x = arg2;
7624
7625 resultobj = SWIG_Py_Void();
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 int result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7645 }
7646 arg1 = reinterpret_cast< wxRect * >(argp1);
7647 result = (int) ((arg1)->x);
7648 resultobj = SWIG_From_int(static_cast< int >(result));
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7656 PyObject *resultobj = 0;
7657 wxRect *arg1 = (wxRect *) 0 ;
7658 int arg2 ;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 int val2 ;
7662 int ecode2 = 0 ;
7663 PyObject *swig_obj[2] ;
7664
7665 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7672 if (!SWIG_IsOK(ecode2)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7674 }
7675 arg2 = static_cast< int >(val2);
7676 if (arg1) (arg1)->y = arg2;
7677
7678 resultobj = SWIG_Py_Void();
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 int result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject *swig_obj[1] ;
7692
7693 if (!args) SWIG_fail;
7694 swig_obj[0] = args;
7695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7698 }
7699 arg1 = reinterpret_cast< wxRect * >(argp1);
7700 result = (int) ((arg1)->y);
7701 resultobj = SWIG_From_int(static_cast< int >(result));
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_width_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_width_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_width_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_width_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->width = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_width_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_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->width);
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_height_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_height_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_height_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_height_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->height = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_height_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_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->height);
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_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 = (int) 0 ;
7818 int arg3 = (int) 0 ;
7819 int arg4 = (int) 0 ;
7820 int arg5 = (int) 0 ;
7821 void *argp1 = 0 ;
7822 int res1 = 0 ;
7823 int val2 ;
7824 int ecode2 = 0 ;
7825 int val3 ;
7826 int ecode3 = 0 ;
7827 int val4 ;
7828 int ecode4 = 0 ;
7829 int val5 ;
7830 int ecode5 = 0 ;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 PyObject * obj2 = 0 ;
7834 PyObject * obj3 = 0 ;
7835 PyObject * obj4 = 0 ;
7836 char * kwnames[] = {
7837 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7838 };
7839
7840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7842 if (!SWIG_IsOK(res1)) {
7843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7844 }
7845 arg1 = reinterpret_cast< wxRect * >(argp1);
7846 if (obj1) {
7847 ecode2 = SWIG_AsVal_int(obj1, &val2);
7848 if (!SWIG_IsOK(ecode2)) {
7849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7850 }
7851 arg2 = static_cast< int >(val2);
7852 }
7853 if (obj2) {
7854 ecode3 = SWIG_AsVal_int(obj2, &val3);
7855 if (!SWIG_IsOK(ecode3)) {
7856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7857 }
7858 arg3 = static_cast< int >(val3);
7859 }
7860 if (obj3) {
7861 ecode4 = SWIG_AsVal_int(obj3, &val4);
7862 if (!SWIG_IsOK(ecode4)) {
7863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7864 }
7865 arg4 = static_cast< int >(val4);
7866 }
7867 if (obj4) {
7868 ecode5 = SWIG_AsVal_int(obj4, &val5);
7869 if (!SWIG_IsOK(ecode5)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7871 }
7872 arg5 = static_cast< int >(val5);
7873 }
7874 {
7875 PyThreadState* __tstate = wxPyBeginAllowThreads();
7876 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 resultobj = SWIG_Py_Void();
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7888 PyObject *resultobj = 0;
7889 wxRect *arg1 = (wxRect *) 0 ;
7890 PyObject *result = 0 ;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 PyObject *swig_obj[1] ;
7894
7895 if (!args) SWIG_fail;
7896 swig_obj[0] = args;
7897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7898 if (!SWIG_IsOK(res1)) {
7899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7900 }
7901 arg1 = reinterpret_cast< wxRect * >(argp1);
7902 {
7903 PyThreadState* __tstate = wxPyBeginAllowThreads();
7904 result = (PyObject *)wxRect_Get(arg1);
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 resultobj = result;
7909 return resultobj;
7910 fail:
7911 return NULL;
7912 }
7913
7914
7915 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7916 PyObject *obj;
7917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7918 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7919 return SWIG_Py_Void();
7920 }
7921
7922 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7923 return SWIG_Python_InitShadowInstance(args);
7924 }
7925
7926 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7927 PyObject *resultobj = 0;
7928 wxRect *arg1 = (wxRect *) 0 ;
7929 wxRect *arg2 = (wxRect *) 0 ;
7930 PyObject *result = 0 ;
7931 void *argp1 = 0 ;
7932 int res1 = 0 ;
7933 void *argp2 = 0 ;
7934 int res2 = 0 ;
7935 PyObject * obj0 = 0 ;
7936 PyObject * obj1 = 0 ;
7937 char * kwnames[] = {
7938 (char *) "r1",(char *) "r2", NULL
7939 };
7940
7941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7943 if (!SWIG_IsOK(res1)) {
7944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7945 }
7946 arg1 = reinterpret_cast< wxRect * >(argp1);
7947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res2)) {
7949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7950 }
7951 arg2 = reinterpret_cast< wxRect * >(argp2);
7952 {
7953 if (!wxPyCheckForApp()) SWIG_fail;
7954 PyThreadState* __tstate = wxPyBeginAllowThreads();
7955 result = (PyObject *)wxIntersectRect(arg1,arg2);
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 resultobj = result;
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7967 PyObject *resultobj = 0;
7968 double arg1 = (double) 0.0 ;
7969 double arg2 = (double) 0.0 ;
7970 wxPoint2D *result = 0 ;
7971 double val1 ;
7972 int ecode1 = 0 ;
7973 double val2 ;
7974 int ecode2 = 0 ;
7975 PyObject * obj0 = 0 ;
7976 PyObject * obj1 = 0 ;
7977 char * kwnames[] = {
7978 (char *) "x",(char *) "y", NULL
7979 };
7980
7981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7982 if (obj0) {
7983 ecode1 = SWIG_AsVal_double(obj0, &val1);
7984 if (!SWIG_IsOK(ecode1)) {
7985 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7986 }
7987 arg1 = static_cast< double >(val1);
7988 }
7989 if (obj1) {
7990 ecode2 = SWIG_AsVal_double(obj1, &val2);
7991 if (!SWIG_IsOK(ecode2)) {
7992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7993 }
7994 arg2 = static_cast< double >(val2);
7995 }
7996 {
7997 PyThreadState* __tstate = wxPyBeginAllowThreads();
7998 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8010 PyObject *resultobj = 0;
8011 wxPoint2D *arg1 = 0 ;
8012 wxPoint2D *result = 0 ;
8013 wxPoint2D temp1 ;
8014 PyObject * obj0 = 0 ;
8015 char * kwnames[] = {
8016 (char *) "pt", NULL
8017 };
8018
8019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8020 {
8021 arg1 = &temp1;
8022 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8023 }
8024 {
8025 PyThreadState* __tstate = wxPyBeginAllowThreads();
8026 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8027 wxPyEndAllowThreads(__tstate);
8028 if (PyErr_Occurred()) SWIG_fail;
8029 }
8030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8031 return resultobj;
8032 fail:
8033 return NULL;
8034 }
8035
8036
8037 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8038 PyObject *resultobj = 0;
8039 wxPoint *arg1 = 0 ;
8040 wxPoint2D *result = 0 ;
8041 wxPoint temp1 ;
8042 PyObject * obj0 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "pt", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8048 {
8049 arg1 = &temp1;
8050 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8051 }
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8055 wxPyEndAllowThreads(__tstate);
8056 if (PyErr_Occurred()) SWIG_fail;
8057 }
8058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8059 return resultobj;
8060 fail:
8061 return NULL;
8062 }
8063
8064
8065 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8066 PyObject *resultobj = 0;
8067 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8068 int *arg2 = (int *) 0 ;
8069 int *arg3 = (int *) 0 ;
8070 void *argp1 = 0 ;
8071 int res1 = 0 ;
8072 int temp2 ;
8073 int res2 = SWIG_TMPOBJ ;
8074 int temp3 ;
8075 int res3 = SWIG_TMPOBJ ;
8076 PyObject *swig_obj[1] ;
8077
8078 arg2 = &temp2;
8079 arg3 = &temp3;
8080 if (!args) SWIG_fail;
8081 swig_obj[0] = args;
8082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8083 if (!SWIG_IsOK(res1)) {
8084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8085 }
8086 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_Py_Void();
8094 if (SWIG_IsTmpObj(res2)) {
8095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8096 } else {
8097 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8099 }
8100 if (SWIG_IsTmpObj(res3)) {
8101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8102 } else {
8103 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8105 }
8106 return resultobj;
8107 fail:
8108 return NULL;
8109 }
8110
8111
8112 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8113 PyObject *resultobj = 0;
8114 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8115 int *arg2 = (int *) 0 ;
8116 int *arg3 = (int *) 0 ;
8117 void *argp1 = 0 ;
8118 int res1 = 0 ;
8119 int temp2 ;
8120 int res2 = SWIG_TMPOBJ ;
8121 int temp3 ;
8122 int res3 = SWIG_TMPOBJ ;
8123 PyObject *swig_obj[1] ;
8124
8125 arg2 = &temp2;
8126 arg3 = &temp3;
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8132 }
8133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 if (SWIG_IsTmpObj(res2)) {
8142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8143 } else {
8144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8146 }
8147 if (SWIG_IsTmpObj(res3)) {
8148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8149 } else {
8150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8152 }
8153 return resultobj;
8154 fail:
8155 return NULL;
8156 }
8157
8158
8159 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8160 PyObject *resultobj = 0;
8161 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8162 double result;
8163 void *argp1 = 0 ;
8164 int res1 = 0 ;
8165 PyObject *swig_obj[1] ;
8166
8167 if (!args) SWIG_fail;
8168 swig_obj[0] = args;
8169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8172 }
8173 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8174 {
8175 PyThreadState* __tstate = wxPyBeginAllowThreads();
8176 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8177 wxPyEndAllowThreads(__tstate);
8178 if (PyErr_Occurred()) SWIG_fail;
8179 }
8180 resultobj = SWIG_From_double(static_cast< double >(result));
8181 return resultobj;
8182 fail:
8183 return NULL;
8184 }
8185
8186
8187 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8188 PyObject *resultobj = 0;
8189 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8190 double result;
8191 void *argp1 = 0 ;
8192 int res1 = 0 ;
8193 PyObject *swig_obj[1] ;
8194
8195 if (!args) SWIG_fail;
8196 swig_obj[0] = args;
8197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8198 if (!SWIG_IsOK(res1)) {
8199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8200 }
8201 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8202 {
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_From_double(static_cast< double >(result));
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8216 PyObject *resultobj = 0;
8217 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8218 double arg2 ;
8219 void *argp1 = 0 ;
8220 int res1 = 0 ;
8221 double val2 ;
8222 int ecode2 = 0 ;
8223 PyObject * obj0 = 0 ;
8224 PyObject * obj1 = 0 ;
8225 char * kwnames[] = {
8226 (char *) "self",(char *) "length", NULL
8227 };
8228
8229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8231 if (!SWIG_IsOK(res1)) {
8232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8233 }
8234 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8235 ecode2 = SWIG_AsVal_double(obj1, &val2);
8236 if (!SWIG_IsOK(ecode2)) {
8237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8238 }
8239 arg2 = static_cast< double >(val2);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 (arg1)->SetVectorLength(arg2);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 return resultobj;
8248 fail:
8249 return NULL;
8250 }
8251
8252
8253 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj = 0;
8255 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8256 double arg2 ;
8257 void *argp1 = 0 ;
8258 int res1 = 0 ;
8259 double val2 ;
8260 int ecode2 = 0 ;
8261 PyObject * obj0 = 0 ;
8262 PyObject * obj1 = 0 ;
8263 char * kwnames[] = {
8264 (char *) "self",(char *) "degrees", NULL
8265 };
8266
8267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8269 if (!SWIG_IsOK(res1)) {
8270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8271 }
8272 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8273 ecode2 = SWIG_AsVal_double(obj1, &val2);
8274 if (!SWIG_IsOK(ecode2)) {
8275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8276 }
8277 arg2 = static_cast< double >(val2);
8278 {
8279 PyThreadState* __tstate = wxPyBeginAllowThreads();
8280 (arg1)->SetVectorAngle(arg2);
8281 wxPyEndAllowThreads(__tstate);
8282 if (PyErr_Occurred()) SWIG_fail;
8283 }
8284 resultobj = SWIG_Py_Void();
8285 return resultobj;
8286 fail:
8287 return NULL;
8288 }
8289
8290
8291 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8292 PyObject *resultobj = 0;
8293 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8294 wxPoint2D *arg2 = 0 ;
8295 double result;
8296 void *argp1 = 0 ;
8297 int res1 = 0 ;
8298 wxPoint2D temp2 ;
8299 PyObject * obj0 = 0 ;
8300 PyObject * obj1 = 0 ;
8301 char * kwnames[] = {
8302 (char *) "self",(char *) "pt", NULL
8303 };
8304
8305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8307 if (!SWIG_IsOK(res1)) {
8308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8309 }
8310 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8311 {
8312 arg2 = &temp2;
8313 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8314 }
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8318 wxPyEndAllowThreads(__tstate);
8319 if (PyErr_Occurred()) SWIG_fail;
8320 }
8321 resultobj = SWIG_From_double(static_cast< double >(result));
8322 return resultobj;
8323 fail:
8324 return NULL;
8325 }
8326
8327
8328 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8329 PyObject *resultobj = 0;
8330 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8331 wxPoint2D *arg2 = 0 ;
8332 double result;
8333 void *argp1 = 0 ;
8334 int res1 = 0 ;
8335 wxPoint2D temp2 ;
8336 PyObject * obj0 = 0 ;
8337 PyObject * obj1 = 0 ;
8338 char * kwnames[] = {
8339 (char *) "self",(char *) "pt", NULL
8340 };
8341
8342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 arg2 = &temp2;
8350 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8351 }
8352 {
8353 PyThreadState* __tstate = wxPyBeginAllowThreads();
8354 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 resultobj = SWIG_From_double(static_cast< double >(result));
8359 return resultobj;
8360 fail:
8361 return NULL;
8362 }
8363
8364
8365 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj = 0;
8367 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8368 wxPoint2D *arg2 = 0 ;
8369 double result;
8370 void *argp1 = 0 ;
8371 int res1 = 0 ;
8372 wxPoint2D temp2 ;
8373 PyObject * obj0 = 0 ;
8374 PyObject * obj1 = 0 ;
8375 char * kwnames[] = {
8376 (char *) "self",(char *) "vec", NULL
8377 };
8378
8379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8381 if (!SWIG_IsOK(res1)) {
8382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8383 }
8384 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8385 {
8386 arg2 = &temp2;
8387 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8388 }
8389 {
8390 PyThreadState* __tstate = wxPyBeginAllowThreads();
8391 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8392 wxPyEndAllowThreads(__tstate);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_From_double(static_cast< double >(result));
8396 return resultobj;
8397 fail:
8398 return NULL;
8399 }
8400
8401
8402 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8403 PyObject *resultobj = 0;
8404 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8405 wxPoint2D *arg2 = 0 ;
8406 double result;
8407 void *argp1 = 0 ;
8408 int res1 = 0 ;
8409 wxPoint2D temp2 ;
8410 PyObject * obj0 = 0 ;
8411 PyObject * obj1 = 0 ;
8412 char * kwnames[] = {
8413 (char *) "self",(char *) "vec", NULL
8414 };
8415
8416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8418 if (!SWIG_IsOK(res1)) {
8419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8420 }
8421 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8422 {
8423 arg2 = &temp2;
8424 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8425 }
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8429 wxPyEndAllowThreads(__tstate);
8430 if (PyErr_Occurred()) SWIG_fail;
8431 }
8432 resultobj = SWIG_From_double(static_cast< double >(result));
8433 return resultobj;
8434 fail:
8435 return NULL;
8436 }
8437
8438
8439 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8440 PyObject *resultobj = 0;
8441 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8442 wxPoint2D result;
8443 void *argp1 = 0 ;
8444 int res1 = 0 ;
8445 PyObject *swig_obj[1] ;
8446
8447 if (!args) SWIG_fail;
8448 swig_obj[0] = args;
8449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 PyThreadState* __tstate = wxPyBeginAllowThreads();
8456 result = (arg1)->operator -();
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8468 PyObject *resultobj = 0;
8469 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8470 wxPoint2D *arg2 = 0 ;
8471 wxPoint2D *result = 0 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 wxPoint2D temp2 ;
8475 PyObject * obj0 = 0 ;
8476 PyObject * obj1 = 0 ;
8477 char * kwnames[] = {
8478 (char *) "self",(char *) "pt", NULL
8479 };
8480
8481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8483 if (!SWIG_IsOK(res1)) {
8484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8485 }
8486 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8487 {
8488 arg2 = &temp2;
8489 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8490 }
8491 {
8492 PyThreadState* __tstate = wxPyBeginAllowThreads();
8493 {
8494 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8495 result = (wxPoint2D *) &_result_ref;
8496 }
8497 wxPyEndAllowThreads(__tstate);
8498 if (PyErr_Occurred()) SWIG_fail;
8499 }
8500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8501 return resultobj;
8502 fail:
8503 return NULL;
8504 }
8505
8506
8507 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8508 PyObject *resultobj = 0;
8509 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8510 wxPoint2D *arg2 = 0 ;
8511 wxPoint2D *result = 0 ;
8512 void *argp1 = 0 ;
8513 int res1 = 0 ;
8514 wxPoint2D temp2 ;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char * kwnames[] = {
8518 (char *) "self",(char *) "pt", NULL
8519 };
8520
8521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8523 if (!SWIG_IsOK(res1)) {
8524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8525 }
8526 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8527 {
8528 arg2 = &temp2;
8529 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8530 }
8531 {
8532 PyThreadState* __tstate = wxPyBeginAllowThreads();
8533 {
8534 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8535 result = (wxPoint2D *) &_result_ref;
8536 }
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj = 0;
8549 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8550 wxPoint2D *arg2 = 0 ;
8551 wxPoint2D *result = 0 ;
8552 void *argp1 = 0 ;
8553 int res1 = 0 ;
8554 wxPoint2D temp2 ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 char * kwnames[] = {
8558 (char *) "self",(char *) "pt", NULL
8559 };
8560
8561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8565 }
8566 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8567 {
8568 arg2 = &temp2;
8569 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 {
8574 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8575 result = (wxPoint2D *) &_result_ref;
8576 }
8577 wxPyEndAllowThreads(__tstate);
8578 if (PyErr_Occurred()) SWIG_fail;
8579 }
8580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8581 return resultobj;
8582 fail:
8583 return NULL;
8584 }
8585
8586
8587 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8588 PyObject *resultobj = 0;
8589 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8590 wxPoint2D *arg2 = 0 ;
8591 wxPoint2D *result = 0 ;
8592 void *argp1 = 0 ;
8593 int res1 = 0 ;
8594 wxPoint2D temp2 ;
8595 PyObject * obj0 = 0 ;
8596 PyObject * obj1 = 0 ;
8597 char * kwnames[] = {
8598 (char *) "self",(char *) "pt", NULL
8599 };
8600
8601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8603 if (!SWIG_IsOK(res1)) {
8604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8605 }
8606 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8607 {
8608 arg2 = &temp2;
8609 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8610 }
8611 {
8612 PyThreadState* __tstate = wxPyBeginAllowThreads();
8613 {
8614 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8615 result = (wxPoint2D *) &_result_ref;
8616 }
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8621 return resultobj;
8622 fail:
8623 return NULL;
8624 }
8625
8626
8627 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8628 PyObject *resultobj = 0;
8629 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8630 PyObject *arg2 = (PyObject *) 0 ;
8631 bool result;
8632 void *argp1 = 0 ;
8633 int res1 = 0 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "other", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 arg2 = obj1;
8647 {
8648 result = (bool)wxPoint2D___eq__(arg1,arg2);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 {
8652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8653 }
8654 return resultobj;
8655 fail:
8656 return NULL;
8657 }
8658
8659
8660 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8661 PyObject *resultobj = 0;
8662 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8663 PyObject *arg2 = (PyObject *) 0 ;
8664 bool result;
8665 void *argp1 = 0 ;
8666 int res1 = 0 ;
8667 PyObject * obj0 = 0 ;
8668 PyObject * obj1 = 0 ;
8669 char * kwnames[] = {
8670 (char *) "self",(char *) "other", NULL
8671 };
8672
8673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8675 if (!SWIG_IsOK(res1)) {
8676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8677 }
8678 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8679 arg2 = obj1;
8680 {
8681 result = (bool)wxPoint2D___ne__(arg1,arg2);
8682 if (PyErr_Occurred()) SWIG_fail;
8683 }
8684 {
8685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8686 }
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 double arg2 ;
8697 void *argp1 = 0 ;
8698 int res1 = 0 ;
8699 double val2 ;
8700 int ecode2 = 0 ;
8701 PyObject *swig_obj[2] ;
8702
8703 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8705 if (!SWIG_IsOK(res1)) {
8706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8707 }
8708 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8709 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8710 if (!SWIG_IsOK(ecode2)) {
8711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8712 }
8713 arg2 = static_cast< double >(val2);
8714 if (arg1) (arg1)->m_x = arg2;
8715
8716 resultobj = SWIG_Py_Void();
8717 return resultobj;
8718 fail:
8719 return NULL;
8720 }
8721
8722
8723 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8724 PyObject *resultobj = 0;
8725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8726 double result;
8727 void *argp1 = 0 ;
8728 int res1 = 0 ;
8729 PyObject *swig_obj[1] ;
8730
8731 if (!args) SWIG_fail;
8732 swig_obj[0] = args;
8733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8734 if (!SWIG_IsOK(res1)) {
8735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8736 }
8737 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8738 result = (double) ((arg1)->m_x);
8739 resultobj = SWIG_From_double(static_cast< double >(result));
8740 return resultobj;
8741 fail:
8742 return NULL;
8743 }
8744
8745
8746 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8747 PyObject *resultobj = 0;
8748 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8749 double arg2 ;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 double val2 ;
8753 int ecode2 = 0 ;
8754 PyObject *swig_obj[2] ;
8755
8756 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8758 if (!SWIG_IsOK(res1)) {
8759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8760 }
8761 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8762 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8763 if (!SWIG_IsOK(ecode2)) {
8764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8765 }
8766 arg2 = static_cast< double >(val2);
8767 if (arg1) (arg1)->m_y = arg2;
8768
8769 resultobj = SWIG_Py_Void();
8770 return resultobj;
8771 fail:
8772 return NULL;
8773 }
8774
8775
8776 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8777 PyObject *resultobj = 0;
8778 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8779 double result;
8780 void *argp1 = 0 ;
8781 int res1 = 0 ;
8782 PyObject *swig_obj[1] ;
8783
8784 if (!args) SWIG_fail;
8785 swig_obj[0] = args;
8786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8787 if (!SWIG_IsOK(res1)) {
8788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8789 }
8790 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8791 result = (double) ((arg1)->m_y);
8792 resultobj = SWIG_From_double(static_cast< double >(result));
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 = (double) 0 ;
8803 double arg3 = (double) 0 ;
8804 void *argp1 = 0 ;
8805 int res1 = 0 ;
8806 double val2 ;
8807 int ecode2 = 0 ;
8808 double val3 ;
8809 int ecode3 = 0 ;
8810 PyObject * obj0 = 0 ;
8811 PyObject * obj1 = 0 ;
8812 PyObject * obj2 = 0 ;
8813 char * kwnames[] = {
8814 (char *) "self",(char *) "x",(char *) "y", NULL
8815 };
8816
8817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8819 if (!SWIG_IsOK(res1)) {
8820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8821 }
8822 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8823 if (obj1) {
8824 ecode2 = SWIG_AsVal_double(obj1, &val2);
8825 if (!SWIG_IsOK(ecode2)) {
8826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8827 }
8828 arg2 = static_cast< double >(val2);
8829 }
8830 if (obj2) {
8831 ecode3 = SWIG_AsVal_double(obj2, &val3);
8832 if (!SWIG_IsOK(ecode3)) {
8833 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8834 }
8835 arg3 = static_cast< double >(val3);
8836 }
8837 {
8838 PyThreadState* __tstate = wxPyBeginAllowThreads();
8839 wxPoint2D_Set(arg1,arg2,arg3);
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_Py_Void();
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8851 PyObject *resultobj = 0;
8852 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8853 PyObject *result = 0 ;
8854 void *argp1 = 0 ;
8855 int res1 = 0 ;
8856 PyObject *swig_obj[1] ;
8857
8858 if (!args) SWIG_fail;
8859 swig_obj[0] = args;
8860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8861 if (!SWIG_IsOK(res1)) {
8862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8863 }
8864 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 result = (PyObject *)wxPoint2D_Get(arg1);
8868 wxPyEndAllowThreads(__tstate);
8869 if (PyErr_Occurred()) SWIG_fail;
8870 }
8871 resultobj = result;
8872 return resultobj;
8873 fail:
8874 return NULL;
8875 }
8876
8877
8878 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8879 PyObject *obj;
8880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8881 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8882 return SWIG_Py_Void();
8883 }
8884
8885 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8886 return SWIG_Python_InitShadowInstance(args);
8887 }
8888
8889 SWIGINTERN int DefaultPosition_set(PyObject *) {
8890 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8891 return 1;
8892 }
8893
8894
8895 SWIGINTERN PyObject *DefaultPosition_get(void) {
8896 PyObject *pyobj = 0;
8897
8898 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8899 return pyobj;
8900 }
8901
8902
8903 SWIGINTERN int DefaultSize_set(PyObject *) {
8904 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8905 return 1;
8906 }
8907
8908
8909 SWIGINTERN PyObject *DefaultSize_get(void) {
8910 PyObject *pyobj = 0;
8911
8912 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8913 return pyobj;
8914 }
8915
8916
8917 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8918 PyObject *resultobj = 0;
8919 PyObject *arg1 = (PyObject *) 0 ;
8920 wxPyInputStream *result = 0 ;
8921 PyObject * obj0 = 0 ;
8922 char * kwnames[] = {
8923 (char *) "p", NULL
8924 };
8925
8926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8927 arg1 = obj0;
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8944 void *argp1 = 0 ;
8945 int res1 = 0 ;
8946 PyObject *swig_obj[1] ;
8947
8948 if (!args) SWIG_fail;
8949 swig_obj[0] = args;
8950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8951 if (!SWIG_IsOK(res1)) {
8952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8953 }
8954 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8955 {
8956 PyThreadState* __tstate = wxPyBeginAllowThreads();
8957 delete arg1;
8958
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = SWIG_Py_Void();
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *resultobj = 0;
8971 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 PyObject *swig_obj[1] ;
8975
8976 if (!args) SWIG_fail;
8977 swig_obj[0] = args;
8978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8979 if (!SWIG_IsOK(res1)) {
8980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8981 }
8982 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 (arg1)->close();
8986 wxPyEndAllowThreads(__tstate);
8987 if (PyErr_Occurred()) SWIG_fail;
8988 }
8989 resultobj = SWIG_Py_Void();
8990 return resultobj;
8991 fail:
8992 return NULL;
8993 }
8994
8995
8996 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8997 PyObject *resultobj = 0;
8998 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 PyObject *swig_obj[1] ;
9002
9003 if (!args) SWIG_fail;
9004 swig_obj[0] = args;
9005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9006 if (!SWIG_IsOK(res1)) {
9007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9008 }
9009 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 (arg1)->flush();
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 resultobj = SWIG_Py_Void();
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9024 PyObject *resultobj = 0;
9025 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9026 bool result;
9027 void *argp1 = 0 ;
9028 int res1 = 0 ;
9029 PyObject *swig_obj[1] ;
9030
9031 if (!args) SWIG_fail;
9032 swig_obj[0] = args;
9033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 result = (bool)(arg1)->eof();
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 {
9045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9046 }
9047 return resultobj;
9048 fail:
9049 return NULL;
9050 }
9051
9052
9053 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9054 PyObject *resultobj = 0;
9055 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9056 int arg2 = (int) -1 ;
9057 PyObject *result = 0 ;
9058 void *argp1 = 0 ;
9059 int res1 = 0 ;
9060 int val2 ;
9061 int ecode2 = 0 ;
9062 PyObject * obj0 = 0 ;
9063 PyObject * obj1 = 0 ;
9064 char * kwnames[] = {
9065 (char *) "self",(char *) "size", NULL
9066 };
9067
9068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9072 }
9073 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9074 if (obj1) {
9075 ecode2 = SWIG_AsVal_int(obj1, &val2);
9076 if (!SWIG_IsOK(ecode2)) {
9077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9078 }
9079 arg2 = static_cast< int >(val2);
9080 }
9081 {
9082 PyThreadState* __tstate = wxPyBeginAllowThreads();
9083 result = (PyObject *)(arg1)->read(arg2);
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 resultobj = result;
9088 return resultobj;
9089 fail:
9090 return NULL;
9091 }
9092
9093
9094 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9095 PyObject *resultobj = 0;
9096 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9097 int arg2 = (int) -1 ;
9098 PyObject *result = 0 ;
9099 void *argp1 = 0 ;
9100 int res1 = 0 ;
9101 int val2 ;
9102 int ecode2 = 0 ;
9103 PyObject * obj0 = 0 ;
9104 PyObject * obj1 = 0 ;
9105 char * kwnames[] = {
9106 (char *) "self",(char *) "size", NULL
9107 };
9108
9109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9111 if (!SWIG_IsOK(res1)) {
9112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9113 }
9114 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9115 if (obj1) {
9116 ecode2 = SWIG_AsVal_int(obj1, &val2);
9117 if (!SWIG_IsOK(ecode2)) {
9118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9119 }
9120 arg2 = static_cast< int >(val2);
9121 }
9122 {
9123 PyThreadState* __tstate = wxPyBeginAllowThreads();
9124 result = (PyObject *)(arg1)->readline(arg2);
9125 wxPyEndAllowThreads(__tstate);
9126 if (PyErr_Occurred()) SWIG_fail;
9127 }
9128 resultobj = result;
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9136 PyObject *resultobj = 0;
9137 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9138 int arg2 = (int) -1 ;
9139 PyObject *result = 0 ;
9140 void *argp1 = 0 ;
9141 int res1 = 0 ;
9142 int val2 ;
9143 int ecode2 = 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 char * kwnames[] = {
9147 (char *) "self",(char *) "sizehint", NULL
9148 };
9149
9150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9152 if (!SWIG_IsOK(res1)) {
9153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9154 }
9155 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9156 if (obj1) {
9157 ecode2 = SWIG_AsVal_int(obj1, &val2);
9158 if (!SWIG_IsOK(ecode2)) {
9159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9160 }
9161 arg2 = static_cast< int >(val2);
9162 }
9163 {
9164 PyThreadState* __tstate = wxPyBeginAllowThreads();
9165 result = (PyObject *)(arg1)->readlines(arg2);
9166 wxPyEndAllowThreads(__tstate);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = result;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9177 PyObject *resultobj = 0;
9178 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9179 int arg2 ;
9180 int arg3 = (int) 0 ;
9181 void *argp1 = 0 ;
9182 int res1 = 0 ;
9183 int val2 ;
9184 int ecode2 = 0 ;
9185 int val3 ;
9186 int ecode3 = 0 ;
9187 PyObject * obj0 = 0 ;
9188 PyObject * obj1 = 0 ;
9189 PyObject * obj2 = 0 ;
9190 char * kwnames[] = {
9191 (char *) "self",(char *) "offset",(char *) "whence", NULL
9192 };
9193
9194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9196 if (!SWIG_IsOK(res1)) {
9197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9198 }
9199 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9200 ecode2 = SWIG_AsVal_int(obj1, &val2);
9201 if (!SWIG_IsOK(ecode2)) {
9202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9203 }
9204 arg2 = static_cast< int >(val2);
9205 if (obj2) {
9206 ecode3 = SWIG_AsVal_int(obj2, &val3);
9207 if (!SWIG_IsOK(ecode3)) {
9208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9209 }
9210 arg3 = static_cast< int >(val3);
9211 }
9212 {
9213 PyThreadState* __tstate = wxPyBeginAllowThreads();
9214 (arg1)->seek(arg2,arg3);
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 resultobj = SWIG_Py_Void();
9219 return resultobj;
9220 fail:
9221 return NULL;
9222 }
9223
9224
9225 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9226 PyObject *resultobj = 0;
9227 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9228 int result;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 PyObject *swig_obj[1] ;
9232
9233 if (!args) SWIG_fail;
9234 swig_obj[0] = args;
9235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9236 if (!SWIG_IsOK(res1)) {
9237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9238 }
9239 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 result = (int)(arg1)->tell();
9243 wxPyEndAllowThreads(__tstate);
9244 if (PyErr_Occurred()) SWIG_fail;
9245 }
9246 resultobj = SWIG_From_int(static_cast< int >(result));
9247 return resultobj;
9248 fail:
9249 return NULL;
9250 }
9251
9252
9253 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9254 PyObject *resultobj = 0;
9255 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9256 char result;
9257 void *argp1 = 0 ;
9258 int res1 = 0 ;
9259 PyObject *swig_obj[1] ;
9260
9261 if (!args) SWIG_fail;
9262 swig_obj[0] = args;
9263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9264 if (!SWIG_IsOK(res1)) {
9265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9266 }
9267 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 result = (char)(arg1)->Peek();
9271 wxPyEndAllowThreads(__tstate);
9272 if (PyErr_Occurred()) SWIG_fail;
9273 }
9274 resultobj = SWIG_From_char(static_cast< char >(result));
9275 return resultobj;
9276 fail:
9277 return NULL;
9278 }
9279
9280
9281 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9282 PyObject *resultobj = 0;
9283 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9284 char result;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9294 }
9295 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 result = (char)(arg1)->GetC();
9299 wxPyEndAllowThreads(__tstate);
9300 if (PyErr_Occurred()) SWIG_fail;
9301 }
9302 resultobj = SWIG_From_char(static_cast< char >(result));
9303 return resultobj;
9304 fail:
9305 return NULL;
9306 }
9307
9308
9309 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9310 PyObject *resultobj = 0;
9311 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9312 size_t result;
9313 void *argp1 = 0 ;
9314 int res1 = 0 ;
9315 PyObject *swig_obj[1] ;
9316
9317 if (!args) SWIG_fail;
9318 swig_obj[0] = args;
9319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 {
9325 PyThreadState* __tstate = wxPyBeginAllowThreads();
9326 result = (size_t)(arg1)->LastRead();
9327 wxPyEndAllowThreads(__tstate);
9328 if (PyErr_Occurred()) SWIG_fail;
9329 }
9330 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9331 return resultobj;
9332 fail:
9333 return NULL;
9334 }
9335
9336
9337 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9338 PyObject *resultobj = 0;
9339 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9340 bool result;
9341 void *argp1 = 0 ;
9342 int res1 = 0 ;
9343 PyObject *swig_obj[1] ;
9344
9345 if (!args) SWIG_fail;
9346 swig_obj[0] = args;
9347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9348 if (!SWIG_IsOK(res1)) {
9349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9350 }
9351 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9352 {
9353 PyThreadState* __tstate = wxPyBeginAllowThreads();
9354 result = (bool)(arg1)->CanRead();
9355 wxPyEndAllowThreads(__tstate);
9356 if (PyErr_Occurred()) SWIG_fail;
9357 }
9358 {
9359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9360 }
9361 return resultobj;
9362 fail:
9363 return NULL;
9364 }
9365
9366
9367 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9368 PyObject *resultobj = 0;
9369 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9370 bool result;
9371 void *argp1 = 0 ;
9372 int res1 = 0 ;
9373 PyObject *swig_obj[1] ;
9374
9375 if (!args) SWIG_fail;
9376 swig_obj[0] = args;
9377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9378 if (!SWIG_IsOK(res1)) {
9379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9380 }
9381 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (bool)(arg1)->Eof();
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 {
9389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9390 }
9391 return resultobj;
9392 fail:
9393 return NULL;
9394 }
9395
9396
9397 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9398 PyObject *resultobj = 0;
9399 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9400 char arg2 ;
9401 bool result;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 char val2 ;
9405 int ecode2 = 0 ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 char * kwnames[] = {
9409 (char *) "self",(char *) "c", NULL
9410 };
9411
9412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9416 }
9417 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9418 ecode2 = SWIG_AsVal_char(obj1, &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9421 }
9422 arg2 = static_cast< char >(val2);
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = (bool)(arg1)->Ungetch(arg2);
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9431 }
9432 return resultobj;
9433 fail:
9434 return NULL;
9435 }
9436
9437
9438 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj = 0;
9440 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9441 long arg2 ;
9442 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9443 long result;
9444 void *argp1 = 0 ;
9445 int res1 = 0 ;
9446 long val2 ;
9447 int ecode2 = 0 ;
9448 int val3 ;
9449 int ecode3 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 PyObject * obj2 = 0 ;
9453 char * kwnames[] = {
9454 (char *) "self",(char *) "pos",(char *) "mode", NULL
9455 };
9456
9457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9459 if (!SWIG_IsOK(res1)) {
9460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9461 }
9462 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9463 ecode2 = SWIG_AsVal_long(obj1, &val2);
9464 if (!SWIG_IsOK(ecode2)) {
9465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9466 }
9467 arg2 = static_cast< long >(val2);
9468 if (obj2) {
9469 ecode3 = SWIG_AsVal_int(obj2, &val3);
9470 if (!SWIG_IsOK(ecode3)) {
9471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9472 }
9473 arg3 = static_cast< wxSeekMode >(val3);
9474 }
9475 {
9476 PyThreadState* __tstate = wxPyBeginAllowThreads();
9477 result = (long)(arg1)->SeekI(arg2,arg3);
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_From_long(static_cast< long >(result));
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 long result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 PyObject *swig_obj[1] ;
9495
9496 if (!args) SWIG_fail;
9497 swig_obj[0] = args;
9498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9499 if (!SWIG_IsOK(res1)) {
9500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9501 }
9502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9503 {
9504 PyThreadState* __tstate = wxPyBeginAllowThreads();
9505 result = (long)(arg1)->TellI();
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 resultobj = SWIG_From_long(static_cast< long >(result));
9510 return resultobj;
9511 fail:
9512 return NULL;
9513 }
9514
9515
9516 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9517 PyObject *obj;
9518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9519 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9520 return SWIG_Py_Void();
9521 }
9522
9523 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9524 return SWIG_Python_InitShadowInstance(args);
9525 }
9526
9527 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9528 PyObject *resultobj = 0;
9529 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9530 PyObject *arg2 = (PyObject *) 0 ;
9531 void *argp1 = 0 ;
9532 int res1 = 0 ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 char * kwnames[] = {
9536 (char *) "self",(char *) "obj", NULL
9537 };
9538
9539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9541 if (!SWIG_IsOK(res1)) {
9542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9543 }
9544 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9545 arg2 = obj1;
9546 {
9547 PyThreadState* __tstate = wxPyBeginAllowThreads();
9548 wxOutputStream_write(arg1,arg2);
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9560 PyObject *resultobj = 0;
9561 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9562 size_t result;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 PyObject *swig_obj[1] ;
9566
9567 if (!args) SWIG_fail;
9568 swig_obj[0] = args;
9569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9570 if (!SWIG_IsOK(res1)) {
9571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9572 }
9573 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9574 {
9575 PyThreadState* __tstate = wxPyBeginAllowThreads();
9576 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9588 PyObject *obj;
9589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9590 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9591 return SWIG_Py_Void();
9592 }
9593
9594 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9595 PyObject *resultobj = 0;
9596 wxInputStream *arg1 = (wxInputStream *) 0 ;
9597 wxString *arg2 = 0 ;
9598 wxString *arg3 = 0 ;
9599 wxString *arg4 = 0 ;
9600 wxDateTime arg5 ;
9601 wxFSFile *result = 0 ;
9602 wxPyInputStream *temp1 ;
9603 bool temp2 = false ;
9604 bool temp3 = false ;
9605 bool temp4 = false ;
9606 void *argp5 ;
9607 int res5 = 0 ;
9608 PyObject * obj0 = 0 ;
9609 PyObject * obj1 = 0 ;
9610 PyObject * obj2 = 0 ;
9611 PyObject * obj3 = 0 ;
9612 PyObject * obj4 = 0 ;
9613 char * kwnames[] = {
9614 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9615 };
9616
9617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9618 {
9619 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9620 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9621 } else {
9622 PyErr_Clear(); // clear the failure of the wxPyConvert above
9623 arg1 = wxPyCBInputStream_create(obj0, true);
9624 if (arg1 == NULL) {
9625 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9626 SWIG_fail;
9627 }
9628 }
9629 }
9630 {
9631 arg2 = wxString_in_helper(obj1);
9632 if (arg2 == NULL) SWIG_fail;
9633 temp2 = true;
9634 }
9635 {
9636 arg3 = wxString_in_helper(obj2);
9637 if (arg3 == NULL) SWIG_fail;
9638 temp3 = true;
9639 }
9640 {
9641 arg4 = wxString_in_helper(obj3);
9642 if (arg4 == NULL) SWIG_fail;
9643 temp4 = true;
9644 }
9645 {
9646 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9647 if (!SWIG_IsOK(res5)) {
9648 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9649 }
9650 if (!argp5) {
9651 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9652 } else {
9653 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9654 arg5 = *temp;
9655 if (SWIG_IsNewObj(res5)) delete temp;
9656 }
9657 }
9658 {
9659 PyThreadState* __tstate = wxPyBeginAllowThreads();
9660 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9661 wxPyEndAllowThreads(__tstate);
9662 if (PyErr_Occurred()) SWIG_fail;
9663 }
9664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9665 {
9666 if (temp2)
9667 delete arg2;
9668 }
9669 {
9670 if (temp3)
9671 delete arg3;
9672 }
9673 {
9674 if (temp4)
9675 delete arg4;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp2)
9681 delete arg2;
9682 }
9683 {
9684 if (temp3)
9685 delete arg3;
9686 }
9687 {
9688 if (temp4)
9689 delete arg4;
9690 }
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *resultobj = 0;
9697 wxFSFile *arg1 = (wxFSFile *) 0 ;
9698 void *argp1 = 0 ;
9699 int res1 = 0 ;
9700 PyObject *swig_obj[1] ;
9701
9702 if (!args) SWIG_fail;
9703 swig_obj[0] = args;
9704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9705 if (!SWIG_IsOK(res1)) {
9706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9707 }
9708 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 delete arg1;
9712
9713 wxPyEndAllowThreads(__tstate);
9714 if (PyErr_Occurred()) SWIG_fail;
9715 }
9716 resultobj = SWIG_Py_Void();
9717 return resultobj;
9718 fail:
9719 return NULL;
9720 }
9721
9722
9723 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9724 PyObject *resultobj = 0;
9725 wxFSFile *arg1 = (wxFSFile *) 0 ;
9726 wxInputStream *result = 0 ;
9727 void *argp1 = 0 ;
9728 int res1 = 0 ;
9729 PyObject *swig_obj[1] ;
9730
9731 if (!args) SWIG_fail;
9732 swig_obj[0] = args;
9733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9734 if (!SWIG_IsOK(res1)) {
9735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9736 }
9737 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9738 {
9739 PyThreadState* __tstate = wxPyBeginAllowThreads();
9740 result = (wxInputStream *)(arg1)->GetStream();
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 {
9745 wxPyInputStream * _ptr = NULL;
9746
9747 if (result) {
9748 _ptr = new wxPyInputStream(result);
9749 }
9750 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9751 }
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 PyObject *resultobj = 0;
9760 wxFSFile *arg1 = (wxFSFile *) 0 ;
9761 wxString *result = 0 ;
9762 void *argp1 = 0 ;
9763 int res1 = 0 ;
9764 PyObject *swig_obj[1] ;
9765
9766 if (!args) SWIG_fail;
9767 swig_obj[0] = args;
9768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9769 if (!SWIG_IsOK(res1)) {
9770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9771 }
9772 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9773 {
9774 PyThreadState* __tstate = wxPyBeginAllowThreads();
9775 {
9776 wxString const &_result_ref = (arg1)->GetMimeType();
9777 result = (wxString *) &_result_ref;
9778 }
9779 wxPyEndAllowThreads(__tstate);
9780 if (PyErr_Occurred()) SWIG_fail;
9781 }
9782 {
9783 #if wxUSE_UNICODE
9784 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9785 #else
9786 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9787 #endif
9788 }
9789 return resultobj;
9790 fail:
9791 return NULL;
9792 }
9793
9794
9795 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9796 PyObject *resultobj = 0;
9797 wxFSFile *arg1 = (wxFSFile *) 0 ;
9798 wxString *result = 0 ;
9799 void *argp1 = 0 ;
9800 int res1 = 0 ;
9801 PyObject *swig_obj[1] ;
9802
9803 if (!args) SWIG_fail;
9804 swig_obj[0] = args;
9805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9806 if (!SWIG_IsOK(res1)) {
9807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9808 }
9809 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9810 {
9811 PyThreadState* __tstate = wxPyBeginAllowThreads();
9812 {
9813 wxString const &_result_ref = (arg1)->GetLocation();
9814 result = (wxString *) &_result_ref;
9815 }
9816 wxPyEndAllowThreads(__tstate);
9817 if (PyErr_Occurred()) SWIG_fail;
9818 }
9819 {
9820 #if wxUSE_UNICODE
9821 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9822 #else
9823 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9824 #endif
9825 }
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9833 PyObject *resultobj = 0;
9834 wxFSFile *arg1 = (wxFSFile *) 0 ;
9835 wxString *result = 0 ;
9836 void *argp1 = 0 ;
9837 int res1 = 0 ;
9838 PyObject *swig_obj[1] ;
9839
9840 if (!args) SWIG_fail;
9841 swig_obj[0] = args;
9842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9843 if (!SWIG_IsOK(res1)) {
9844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9845 }
9846 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9847 {
9848 PyThreadState* __tstate = wxPyBeginAllowThreads();
9849 {
9850 wxString const &_result_ref = (arg1)->GetAnchor();
9851 result = (wxString *) &_result_ref;
9852 }
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 {
9857 #if wxUSE_UNICODE
9858 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9859 #else
9860 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9861 #endif
9862 }
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9870 PyObject *resultobj = 0;
9871 wxFSFile *arg1 = (wxFSFile *) 0 ;
9872 wxDateTime result;
9873 void *argp1 = 0 ;
9874 int res1 = 0 ;
9875 PyObject *swig_obj[1] ;
9876
9877 if (!args) SWIG_fail;
9878 swig_obj[0] = args;
9879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9882 }
9883 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (arg1)->GetModificationTime();
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *obj;
9899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9900 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9901 return SWIG_Py_Void();
9902 }
9903
9904 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9905 return SWIG_Python_InitShadowInstance(args);
9906 }
9907
9908 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9909 PyObject *resultobj = 0;
9910 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9911 void *argp1 = 0 ;
9912 int res1 = 0 ;
9913 PyObject *swig_obj[1] ;
9914
9915 if (!args) SWIG_fail;
9916 swig_obj[0] = args;
9917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9918 if (!SWIG_IsOK(res1)) {
9919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9920 }
9921 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 delete arg1;
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_Py_Void();
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9937 PyObject *obj;
9938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9939 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9940 return SWIG_Py_Void();
9941 }
9942
9943 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9944 PyObject *resultobj = 0;
9945 wxPyFileSystemHandler *result = 0 ;
9946
9947 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9948 {
9949 PyThreadState* __tstate = wxPyBeginAllowThreads();
9950 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9955 return resultobj;
9956 fail:
9957 return NULL;
9958 }
9959
9960
9961 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9962 PyObject *resultobj = 0;
9963 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9964 PyObject *arg2 = (PyObject *) 0 ;
9965 PyObject *arg3 = (PyObject *) 0 ;
9966 void *argp1 = 0 ;
9967 int res1 = 0 ;
9968 PyObject * obj0 = 0 ;
9969 PyObject * obj1 = 0 ;
9970 PyObject * obj2 = 0 ;
9971 char * kwnames[] = {
9972 (char *) "self",(char *) "self",(char *) "_class", NULL
9973 };
9974
9975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9977 if (!SWIG_IsOK(res1)) {
9978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9979 }
9980 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9981 arg2 = obj1;
9982 arg3 = obj2;
9983 {
9984 PyThreadState* __tstate = wxPyBeginAllowThreads();
9985 (arg1)->_setCallbackInfo(arg2,arg3);
9986 wxPyEndAllowThreads(__tstate);
9987 if (PyErr_Occurred()) SWIG_fail;
9988 }
9989 resultobj = SWIG_Py_Void();
9990 return resultobj;
9991 fail:
9992 return NULL;
9993 }
9994
9995
9996 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9997 PyObject *resultobj = 0;
9998 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9999 wxString *arg2 = 0 ;
10000 bool result;
10001 void *argp1 = 0 ;
10002 int res1 = 0 ;
10003 bool temp2 = false ;
10004 PyObject * obj0 = 0 ;
10005 PyObject * obj1 = 0 ;
10006 char * kwnames[] = {
10007 (char *) "self",(char *) "location", NULL
10008 };
10009
10010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10012 if (!SWIG_IsOK(res1)) {
10013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10014 }
10015 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10016 {
10017 arg2 = wxString_in_helper(obj1);
10018 if (arg2 == NULL) SWIG_fail;
10019 temp2 = true;
10020 }
10021 {
10022 PyThreadState* __tstate = wxPyBeginAllowThreads();
10023 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10024 wxPyEndAllowThreads(__tstate);
10025 if (PyErr_Occurred()) SWIG_fail;
10026 }
10027 {
10028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10029 }
10030 {
10031 if (temp2)
10032 delete arg2;
10033 }
10034 return resultobj;
10035 fail:
10036 {
10037 if (temp2)
10038 delete arg2;
10039 }
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10047 wxFileSystem *arg2 = 0 ;
10048 wxString *arg3 = 0 ;
10049 wxFSFile *result = 0 ;
10050 void *argp1 = 0 ;
10051 int res1 = 0 ;
10052 void *argp2 = 0 ;
10053 int res2 = 0 ;
10054 bool temp3 = false ;
10055 PyObject * obj0 = 0 ;
10056 PyObject * obj1 = 0 ;
10057 PyObject * obj2 = 0 ;
10058 char * kwnames[] = {
10059 (char *) "self",(char *) "fs",(char *) "location", NULL
10060 };
10061
10062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10066 }
10067 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10069 if (!SWIG_IsOK(res2)) {
10070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10071 }
10072 if (!argp2) {
10073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10074 }
10075 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10076 {
10077 arg3 = wxString_in_helper(obj2);
10078 if (arg3 == NULL) SWIG_fail;
10079 temp3 = true;
10080 }
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10089 }
10090 {
10091 if (temp3)
10092 delete arg3;
10093 }
10094 return resultobj;
10095 fail:
10096 {
10097 if (temp3)
10098 delete arg3;
10099 }
10100 return NULL;
10101 }
10102
10103
10104 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10105 PyObject *resultobj = 0;
10106 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10107 wxString *arg2 = 0 ;
10108 int arg3 = (int) 0 ;
10109 wxString result;
10110 void *argp1 = 0 ;
10111 int res1 = 0 ;
10112 bool temp2 = false ;
10113 int val3 ;
10114 int ecode3 = 0 ;
10115 PyObject * obj0 = 0 ;
10116 PyObject * obj1 = 0 ;
10117 PyObject * obj2 = 0 ;
10118 char * kwnames[] = {
10119 (char *) "self",(char *) "spec",(char *) "flags", NULL
10120 };
10121
10122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10124 if (!SWIG_IsOK(res1)) {
10125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10126 }
10127 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10128 {
10129 arg2 = wxString_in_helper(obj1);
10130 if (arg2 == NULL) SWIG_fail;
10131 temp2 = true;
10132 }
10133 if (obj2) {
10134 ecode3 = SWIG_AsVal_int(obj2, &val3);
10135 if (!SWIG_IsOK(ecode3)) {
10136 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10137 }
10138 arg3 = static_cast< int >(val3);
10139 }
10140 {
10141 PyThreadState* __tstate = wxPyBeginAllowThreads();
10142 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10143 wxPyEndAllowThreads(__tstate);
10144 if (PyErr_Occurred()) SWIG_fail;
10145 }
10146 {
10147 #if wxUSE_UNICODE
10148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10149 #else
10150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10151 #endif
10152 }
10153 {
10154 if (temp2)
10155 delete arg2;
10156 }
10157 return resultobj;
10158 fail:
10159 {
10160 if (temp2)
10161 delete arg2;
10162 }
10163 return NULL;
10164 }
10165
10166
10167 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10168 PyObject *resultobj = 0;
10169 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10170 wxString result;
10171 void *argp1 = 0 ;
10172 int res1 = 0 ;
10173 PyObject *swig_obj[1] ;
10174
10175 if (!args) SWIG_fail;
10176 swig_obj[0] = args;
10177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10180 }
10181 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10182 {
10183 PyThreadState* __tstate = wxPyBeginAllowThreads();
10184 result = (arg1)->FindNext();
10185 wxPyEndAllowThreads(__tstate);
10186 if (PyErr_Occurred()) SWIG_fail;
10187 }
10188 {
10189 #if wxUSE_UNICODE
10190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10191 #else
10192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10193 #endif
10194 }
10195 return resultobj;
10196 fail:
10197 return NULL;
10198 }
10199
10200
10201 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10202 PyObject *resultobj = 0;
10203 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10204 wxString *arg2 = 0 ;
10205 wxString result;
10206 void *argp1 = 0 ;
10207 int res1 = 0 ;
10208 bool temp2 = false ;
10209 PyObject * obj0 = 0 ;
10210 PyObject * obj1 = 0 ;
10211 char * kwnames[] = {
10212 (char *) "self",(char *) "location", NULL
10213 };
10214
10215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10217 if (!SWIG_IsOK(res1)) {
10218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10219 }
10220 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10221 {
10222 arg2 = wxString_in_helper(obj1);
10223 if (arg2 == NULL) SWIG_fail;
10224 temp2 = true;
10225 }
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (arg1)->GetProtocol((wxString const &)*arg2);
10229 wxPyEndAllowThreads(__tstate);
10230 if (PyErr_Occurred()) SWIG_fail;
10231 }
10232 {
10233 #if wxUSE_UNICODE
10234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10235 #else
10236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10237 #endif
10238 }
10239 {
10240 if (temp2)
10241 delete arg2;
10242 }
10243 return resultobj;
10244 fail:
10245 {
10246 if (temp2)
10247 delete arg2;
10248 }
10249 return NULL;
10250 }
10251
10252
10253 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj = 0;
10255 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10256 wxString *arg2 = 0 ;
10257 wxString result;
10258 void *argp1 = 0 ;
10259 int res1 = 0 ;
10260 bool temp2 = false ;
10261 PyObject * obj0 = 0 ;
10262 PyObject * obj1 = 0 ;
10263 char * kwnames[] = {
10264 (char *) "self",(char *) "location", NULL
10265 };
10266
10267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10269 if (!SWIG_IsOK(res1)) {
10270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10271 }
10272 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10273 {
10274 arg2 = wxString_in_helper(obj1);
10275 if (arg2 == NULL) SWIG_fail;
10276 temp2 = true;
10277 }
10278 {
10279 PyThreadState* __tstate = wxPyBeginAllowThreads();
10280 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 {
10285 #if wxUSE_UNICODE
10286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10287 #else
10288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10289 #endif
10290 }
10291 {
10292 if (temp2)
10293 delete arg2;
10294 }
10295 return resultobj;
10296 fail:
10297 {
10298 if (temp2)
10299 delete arg2;
10300 }
10301 return NULL;
10302 }
10303
10304
10305 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj = 0;
10307 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10308 wxString *arg2 = 0 ;
10309 wxString result;
10310 void *argp1 = 0 ;
10311 int res1 = 0 ;
10312 bool temp2 = false ;
10313 PyObject * obj0 = 0 ;
10314 PyObject * obj1 = 0 ;
10315 char * kwnames[] = {
10316 (char *) "self",(char *) "location", NULL
10317 };
10318
10319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10321 if (!SWIG_IsOK(res1)) {
10322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10323 }
10324 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10325 {
10326 arg2 = wxString_in_helper(obj1);
10327 if (arg2 == NULL) SWIG_fail;
10328 temp2 = true;
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (arg1)->GetAnchor((wxString const &)*arg2);
10333 wxPyEndAllowThreads(__tstate);
10334 if (PyErr_Occurred()) SWIG_fail;
10335 }
10336 {
10337 #if wxUSE_UNICODE
10338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10339 #else
10340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10341 #endif
10342 }
10343 {
10344 if (temp2)
10345 delete arg2;
10346 }
10347 return resultobj;
10348 fail:
10349 {
10350 if (temp2)
10351 delete arg2;
10352 }
10353 return NULL;
10354 }
10355
10356
10357 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10358 PyObject *resultobj = 0;
10359 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10360 wxString *arg2 = 0 ;
10361 wxString result;
10362 void *argp1 = 0 ;
10363 int res1 = 0 ;
10364 bool temp2 = false ;
10365 PyObject * obj0 = 0 ;
10366 PyObject * obj1 = 0 ;
10367 char * kwnames[] = {
10368 (char *) "self",(char *) "location", NULL
10369 };
10370
10371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10373 if (!SWIG_IsOK(res1)) {
10374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10375 }
10376 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10377 {
10378 arg2 = wxString_in_helper(obj1);
10379 if (arg2 == NULL) SWIG_fail;
10380 temp2 = true;
10381 }
10382 {
10383 PyThreadState* __tstate = wxPyBeginAllowThreads();
10384 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10385 wxPyEndAllowThreads(__tstate);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 #if wxUSE_UNICODE
10390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10391 #else
10392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10393 #endif
10394 }
10395 {
10396 if (temp2)
10397 delete arg2;
10398 }
10399 return resultobj;
10400 fail:
10401 {
10402 if (temp2)
10403 delete arg2;
10404 }
10405 return NULL;
10406 }
10407
10408
10409 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10410 PyObject *resultobj = 0;
10411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10412 wxString *arg2 = 0 ;
10413 wxString result;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 bool temp2 = false ;
10417 PyObject * obj0 = 0 ;
10418 PyObject * obj1 = 0 ;
10419 char * kwnames[] = {
10420 (char *) "self",(char *) "location", NULL
10421 };
10422
10423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10425 if (!SWIG_IsOK(res1)) {
10426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10427 }
10428 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10429 {
10430 arg2 = wxString_in_helper(obj1);
10431 if (arg2 == NULL) SWIG_fail;
10432 temp2 = true;
10433 }
10434 {
10435 PyThreadState* __tstate = wxPyBeginAllowThreads();
10436 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 {
10441 #if wxUSE_UNICODE
10442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10443 #else
10444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10445 #endif
10446 }
10447 {
10448 if (temp2)
10449 delete arg2;
10450 }
10451 return resultobj;
10452 fail:
10453 {
10454 if (temp2)
10455 delete arg2;
10456 }
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *obj;
10463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10464 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10465 return SWIG_Py_Void();
10466 }
10467
10468 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10469 return SWIG_Python_InitShadowInstance(args);
10470 }
10471
10472 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10473 PyObject *resultobj = 0;
10474 wxFileSystem *result = 0 ;
10475
10476 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (wxFileSystem *)new wxFileSystem();
10480 wxPyEndAllowThreads(__tstate);
10481 if (PyErr_Occurred()) SWIG_fail;
10482 }
10483 {
10484 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10485 }
10486 return resultobj;
10487 fail:
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10493 PyObject *resultobj = 0;
10494 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 PyObject *swig_obj[1] ;
10498
10499 if (!args) SWIG_fail;
10500 swig_obj[0] = args;
10501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10502 if (!SWIG_IsOK(res1)) {
10503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10504 }
10505 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 delete arg1;
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_Py_Void();
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj = 0;
10522 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10523 wxString *arg2 = 0 ;
10524 bool arg3 = (bool) false ;
10525 void *argp1 = 0 ;
10526 int res1 = 0 ;
10527 bool temp2 = false ;
10528 bool val3 ;
10529 int ecode3 = 0 ;
10530 PyObject * obj0 = 0 ;
10531 PyObject * obj1 = 0 ;
10532 PyObject * obj2 = 0 ;
10533 char * kwnames[] = {
10534 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10535 };
10536
10537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10539 if (!SWIG_IsOK(res1)) {
10540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10541 }
10542 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10543 {
10544 arg2 = wxString_in_helper(obj1);
10545 if (arg2 == NULL) SWIG_fail;
10546 temp2 = true;
10547 }
10548 if (obj2) {
10549 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10550 if (!SWIG_IsOK(ecode3)) {
10551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10552 }
10553 arg3 = static_cast< bool >(val3);
10554 }
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 {
10563 if (temp2)
10564 delete arg2;
10565 }
10566 return resultobj;
10567 fail:
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return NULL;
10573 }
10574
10575
10576 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10577 PyObject *resultobj = 0;
10578 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10579 wxString result;
10580 void *argp1 = 0 ;
10581 int res1 = 0 ;
10582 PyObject *swig_obj[1] ;
10583
10584 if (!args) SWIG_fail;
10585 swig_obj[0] = args;
10586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10589 }
10590 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (arg1)->GetPath();
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10611 PyObject *resultobj = 0;
10612 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10613 wxString *arg2 = 0 ;
10614 wxFSFile *result = 0 ;
10615 void *argp1 = 0 ;
10616 int res1 = 0 ;
10617 bool temp2 = false ;
10618 PyObject * obj0 = 0 ;
10619 PyObject * obj1 = 0 ;
10620 char * kwnames[] = {
10621 (char *) "self",(char *) "location", NULL
10622 };
10623
10624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10626 if (!SWIG_IsOK(res1)) {
10627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10628 }
10629 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10630 {
10631 arg2 = wxString_in_helper(obj1);
10632 if (arg2 == NULL) SWIG_fail;
10633 temp2 = true;
10634 }
10635 {
10636 PyThreadState* __tstate = wxPyBeginAllowThreads();
10637 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10638 wxPyEndAllowThreads(__tstate);
10639 if (PyErr_Occurred()) SWIG_fail;
10640 }
10641 {
10642 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10643 }
10644 {
10645 if (temp2)
10646 delete arg2;
10647 }
10648 return resultobj;
10649 fail:
10650 {
10651 if (temp2)
10652 delete arg2;
10653 }
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10659 PyObject *resultobj = 0;
10660 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10661 wxString *arg2 = 0 ;
10662 int arg3 = (int) 0 ;
10663 wxString result;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 bool temp2 = false ;
10667 int val3 ;
10668 int ecode3 = 0 ;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 PyObject * obj2 = 0 ;
10672 char * kwnames[] = {
10673 (char *) "self",(char *) "spec",(char *) "flags", NULL
10674 };
10675
10676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10678 if (!SWIG_IsOK(res1)) {
10679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10680 }
10681 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10682 {
10683 arg2 = wxString_in_helper(obj1);
10684 if (arg2 == NULL) SWIG_fail;
10685 temp2 = true;
10686 }
10687 if (obj2) {
10688 ecode3 = SWIG_AsVal_int(obj2, &val3);
10689 if (!SWIG_IsOK(ecode3)) {
10690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10691 }
10692 arg3 = static_cast< int >(val3);
10693 }
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 {
10701 #if wxUSE_UNICODE
10702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10703 #else
10704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10705 #endif
10706 }
10707 {
10708 if (temp2)
10709 delete arg2;
10710 }
10711 return resultobj;
10712 fail:
10713 {
10714 if (temp2)
10715 delete arg2;
10716 }
10717 return NULL;
10718 }
10719
10720
10721 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10722 PyObject *resultobj = 0;
10723 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10724 wxString result;
10725 void *argp1 = 0 ;
10726 int res1 = 0 ;
10727 PyObject *swig_obj[1] ;
10728
10729 if (!args) SWIG_fail;
10730 swig_obj[0] = args;
10731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10732 if (!SWIG_IsOK(res1)) {
10733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10734 }
10735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10736 {
10737 PyThreadState* __tstate = wxPyBeginAllowThreads();
10738 result = (arg1)->FindNext();
10739 wxPyEndAllowThreads(__tstate);
10740 if (PyErr_Occurred()) SWIG_fail;
10741 }
10742 {
10743 #if wxUSE_UNICODE
10744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10745 #else
10746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10747 #endif
10748 }
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj = 0;
10757 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10758 int res1 = 0 ;
10759 PyObject * obj0 = 0 ;
10760 char * kwnames[] = {
10761 (char *) "handler", NULL
10762 };
10763
10764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10765 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10766 if (!SWIG_IsOK(res1)) {
10767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10768 }
10769 {
10770 PyThreadState* __tstate = wxPyBeginAllowThreads();
10771 wxFileSystem::AddHandler(arg1);
10772 wxPyEndAllowThreads(__tstate);
10773 if (PyErr_Occurred()) SWIG_fail;
10774 }
10775 resultobj = SWIG_Py_Void();
10776 return resultobj;
10777 fail:
10778 return NULL;
10779 }
10780
10781
10782 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10783 PyObject *resultobj = 0;
10784
10785 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10786 {
10787 PyThreadState* __tstate = wxPyBeginAllowThreads();
10788 wxFileSystem::CleanUpHandlers();
10789 wxPyEndAllowThreads(__tstate);
10790 if (PyErr_Occurred()) SWIG_fail;
10791 }
10792 resultobj = SWIG_Py_Void();
10793 return resultobj;
10794 fail:
10795 return NULL;
10796 }
10797
10798
10799 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj = 0;
10801 wxString *arg1 = 0 ;
10802 wxString result;
10803 bool temp1 = false ;
10804 PyObject * obj0 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "filename", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10810 {
10811 arg1 = wxString_in_helper(obj0);
10812 if (arg1 == NULL) SWIG_fail;
10813 temp1 = true;
10814 }
10815 {
10816 PyThreadState* __tstate = wxPyBeginAllowThreads();
10817 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10818 wxPyEndAllowThreads(__tstate);
10819 if (PyErr_Occurred()) SWIG_fail;
10820 }
10821 {
10822 #if wxUSE_UNICODE
10823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10824 #else
10825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10826 #endif
10827 }
10828 {
10829 if (temp1)
10830 delete arg1;
10831 }
10832 return resultobj;
10833 fail:
10834 {
10835 if (temp1)
10836 delete arg1;
10837 }
10838 return NULL;
10839 }
10840
10841
10842 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj = 0;
10844 wxString *arg1 = 0 ;
10845 wxString result;
10846 bool temp1 = false ;
10847 PyObject * obj0 = 0 ;
10848 char * kwnames[] = {
10849 (char *) "url", NULL
10850 };
10851
10852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10853 {
10854 arg1 = wxString_in_helper(obj0);
10855 if (arg1 == NULL) SWIG_fail;
10856 temp1 = true;
10857 }
10858 {
10859 PyThreadState* __tstate = wxPyBeginAllowThreads();
10860 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10861 wxPyEndAllowThreads(__tstate);
10862 if (PyErr_Occurred()) SWIG_fail;
10863 }
10864 {
10865 #if wxUSE_UNICODE
10866 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10867 #else
10868 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10869 #endif
10870 }
10871 {
10872 if (temp1)
10873 delete arg1;
10874 }
10875 return resultobj;
10876 fail:
10877 {
10878 if (temp1)
10879 delete arg1;
10880 }
10881 return NULL;
10882 }
10883
10884
10885 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *obj;
10887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10888 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10889 return SWIG_Py_Void();
10890 }
10891
10892 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10893 return SWIG_Python_InitShadowInstance(args);
10894 }
10895
10896 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10897 PyObject *resultobj = 0;
10898 wxInternetFSHandler *result = 0 ;
10899
10900 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10901 {
10902 PyThreadState* __tstate = wxPyBeginAllowThreads();
10903 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10917 wxString *arg2 = 0 ;
10918 bool result;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 bool temp2 = false ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "location", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10932 }
10933 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10934 {
10935 arg2 = wxString_in_helper(obj1);
10936 if (arg2 == NULL) SWIG_fail;
10937 temp2 = true;
10938 }
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10942 wxPyEndAllowThreads(__tstate);
10943 if (PyErr_Occurred()) SWIG_fail;
10944 }
10945 {
10946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10947 }
10948 {
10949 if (temp2)
10950 delete arg2;
10951 }
10952 return resultobj;
10953 fail:
10954 {
10955 if (temp2)
10956 delete arg2;
10957 }
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10965 wxFileSystem *arg2 = 0 ;
10966 wxString *arg3 = 0 ;
10967 wxFSFile *result = 0 ;
10968 void *argp1 = 0 ;
10969 int res1 = 0 ;
10970 void *argp2 = 0 ;
10971 int res2 = 0 ;
10972 bool temp3 = false ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 PyObject * obj2 = 0 ;
10976 char * kwnames[] = {
10977 (char *) "self",(char *) "fs",(char *) "location", NULL
10978 };
10979
10980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10984 }
10985 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10986 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10987 if (!SWIG_IsOK(res2)) {
10988 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10989 }
10990 if (!argp2) {
10991 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10992 }
10993 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10994 {
10995 arg3 = wxString_in_helper(obj2);
10996 if (arg3 == NULL) SWIG_fail;
10997 temp3 = true;
10998 }
10999 {
11000 PyThreadState* __tstate = wxPyBeginAllowThreads();
11001 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11002 wxPyEndAllowThreads(__tstate);
11003 if (PyErr_Occurred()) SWIG_fail;
11004 }
11005 {
11006 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11007 }
11008 {
11009 if (temp3)
11010 delete arg3;
11011 }
11012 return resultobj;
11013 fail:
11014 {
11015 if (temp3)
11016 delete arg3;
11017 }
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 PyObject *obj;
11024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11025 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11026 return SWIG_Py_Void();
11027 }
11028
11029 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11030 return SWIG_Python_InitShadowInstance(args);
11031 }
11032
11033 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11034 PyObject *resultobj = 0;
11035 wxZipFSHandler *result = 0 ;
11036
11037 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = (wxZipFSHandler *)new wxZipFSHandler();
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11045 return resultobj;
11046 fail:
11047 return NULL;
11048 }
11049
11050
11051 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11052 PyObject *resultobj = 0;
11053 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11054 wxString *arg2 = 0 ;
11055 bool result;
11056 void *argp1 = 0 ;
11057 int res1 = 0 ;
11058 bool temp2 = false ;
11059 PyObject * obj0 = 0 ;
11060 PyObject * obj1 = 0 ;
11061 char * kwnames[] = {
11062 (char *) "self",(char *) "location", NULL
11063 };
11064
11065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11067 if (!SWIG_IsOK(res1)) {
11068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11069 }
11070 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11071 {
11072 arg2 = wxString_in_helper(obj1);
11073 if (arg2 == NULL) SWIG_fail;
11074 temp2 = true;
11075 }
11076 {
11077 PyThreadState* __tstate = wxPyBeginAllowThreads();
11078 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11079 wxPyEndAllowThreads(__tstate);
11080 if (PyErr_Occurred()) SWIG_fail;
11081 }
11082 {
11083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11084 }
11085 {
11086 if (temp2)
11087 delete arg2;
11088 }
11089 return resultobj;
11090 fail:
11091 {
11092 if (temp2)
11093 delete arg2;
11094 }
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11102 wxFileSystem *arg2 = 0 ;
11103 wxString *arg3 = 0 ;
11104 wxFSFile *result = 0 ;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 void *argp2 = 0 ;
11108 int res2 = 0 ;
11109 bool temp3 = false ;
11110 PyObject * obj0 = 0 ;
11111 PyObject * obj1 = 0 ;
11112 PyObject * obj2 = 0 ;
11113 char * kwnames[] = {
11114 (char *) "self",(char *) "fs",(char *) "location", NULL
11115 };
11116
11117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11119 if (!SWIG_IsOK(res1)) {
11120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11121 }
11122 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11123 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11124 if (!SWIG_IsOK(res2)) {
11125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11126 }
11127 if (!argp2) {
11128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11129 }
11130 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11131 {
11132 arg3 = wxString_in_helper(obj2);
11133 if (arg3 == NULL) SWIG_fail;
11134 temp3 = true;
11135 }
11136 {
11137 PyThreadState* __tstate = wxPyBeginAllowThreads();
11138 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11139 wxPyEndAllowThreads(__tstate);
11140 if (PyErr_Occurred()) SWIG_fail;
11141 }
11142 {
11143 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11144 }
11145 {
11146 if (temp3)
11147 delete arg3;
11148 }
11149 return resultobj;
11150 fail:
11151 {
11152 if (temp3)
11153 delete arg3;
11154 }
11155 return NULL;
11156 }
11157
11158
11159 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11160 PyObject *resultobj = 0;
11161 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11162 wxString *arg2 = 0 ;
11163 int arg3 = (int) 0 ;
11164 wxString result;
11165 void *argp1 = 0 ;
11166 int res1 = 0 ;
11167 bool temp2 = false ;
11168 int val3 ;
11169 int ecode3 = 0 ;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char * kwnames[] = {
11174 (char *) "self",(char *) "spec",(char *) "flags", NULL
11175 };
11176
11177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11179 if (!SWIG_IsOK(res1)) {
11180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11181 }
11182 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11183 {
11184 arg2 = wxString_in_helper(obj1);
11185 if (arg2 == NULL) SWIG_fail;
11186 temp2 = true;
11187 }
11188 if (obj2) {
11189 ecode3 = SWIG_AsVal_int(obj2, &val3);
11190 if (!SWIG_IsOK(ecode3)) {
11191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11192 }
11193 arg3 = static_cast< int >(val3);
11194 }
11195 {
11196 PyThreadState* __tstate = wxPyBeginAllowThreads();
11197 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11198 wxPyEndAllowThreads(__tstate);
11199 if (PyErr_Occurred()) SWIG_fail;
11200 }
11201 {
11202 #if wxUSE_UNICODE
11203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11204 #else
11205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11206 #endif
11207 }
11208 {
11209 if (temp2)
11210 delete arg2;
11211 }
11212 return resultobj;
11213 fail:
11214 {
11215 if (temp2)
11216 delete arg2;
11217 }
11218 return NULL;
11219 }
11220
11221
11222 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11223 PyObject *resultobj = 0;
11224 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11225 wxString result;
11226 void *argp1 = 0 ;
11227 int res1 = 0 ;
11228 PyObject *swig_obj[1] ;
11229
11230 if (!args) SWIG_fail;
11231 swig_obj[0] = args;
11232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11233 if (!SWIG_IsOK(res1)) {
11234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11235 }
11236 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11237 {
11238 PyThreadState* __tstate = wxPyBeginAllowThreads();
11239 result = (arg1)->FindNext();
11240 wxPyEndAllowThreads(__tstate);
11241 if (PyErr_Occurred()) SWIG_fail;
11242 }
11243 {
11244 #if wxUSE_UNICODE
11245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11246 #else
11247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11248 #endif
11249 }
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *obj;
11258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11259 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11260 return SWIG_Py_Void();
11261 }
11262
11263 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11264 return SWIG_Python_InitShadowInstance(args);
11265 }
11266
11267 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11268 PyObject *resultobj = 0;
11269 wxString *arg1 = 0 ;
11270 wxImage *arg2 = 0 ;
11271 long arg3 ;
11272 bool temp1 = false ;
11273 void *argp2 = 0 ;
11274 int res2 = 0 ;
11275 long val3 ;
11276 int ecode3 = 0 ;
11277 PyObject * obj0 = 0 ;
11278 PyObject * obj1 = 0 ;
11279 PyObject * obj2 = 0 ;
11280 char * kwnames[] = {
11281 (char *) "filename",(char *) "image",(char *) "type", NULL
11282 };
11283
11284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11285 {
11286 arg1 = wxString_in_helper(obj0);
11287 if (arg1 == NULL) SWIG_fail;
11288 temp1 = true;
11289 }
11290 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11291 if (!SWIG_IsOK(res2)) {
11292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11293 }
11294 if (!argp2) {
11295 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11296 }
11297 arg2 = reinterpret_cast< wxImage * >(argp2);
11298 ecode3 = SWIG_AsVal_long(obj2, &val3);
11299 if (!SWIG_IsOK(ecode3)) {
11300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11301 }
11302 arg3 = static_cast< long >(val3);
11303 {
11304 PyThreadState* __tstate = wxPyBeginAllowThreads();
11305 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11306 wxPyEndAllowThreads(__tstate);
11307 if (PyErr_Occurred()) SWIG_fail;
11308 }
11309 resultobj = SWIG_Py_Void();
11310 {
11311 if (temp1)
11312 delete arg1;
11313 }
11314 return resultobj;
11315 fail:
11316 {
11317 if (temp1)
11318 delete arg1;
11319 }
11320 return NULL;
11321 }
11322
11323
11324 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj = 0;
11326 wxString *arg1 = 0 ;
11327 wxBitmap *arg2 = 0 ;
11328 long arg3 ;
11329 bool temp1 = false ;
11330 void *argp2 = 0 ;
11331 int res2 = 0 ;
11332 long val3 ;
11333 int ecode3 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 char * kwnames[] = {
11338 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11339 };
11340
11341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11342 {
11343 arg1 = wxString_in_helper(obj0);
11344 if (arg1 == NULL) SWIG_fail;
11345 temp1 = true;
11346 }
11347 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11348 if (!SWIG_IsOK(res2)) {
11349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11350 }
11351 if (!argp2) {
11352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11353 }
11354 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11355 ecode3 = SWIG_AsVal_long(obj2, &val3);
11356 if (!SWIG_IsOK(ecode3)) {
11357 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11358 }
11359 arg3 = static_cast< long >(val3);
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 resultobj = SWIG_Py_Void();
11367 {
11368 if (temp1)
11369 delete arg1;
11370 }
11371 return resultobj;
11372 fail:
11373 {
11374 if (temp1)
11375 delete arg1;
11376 }
11377 return NULL;
11378 }
11379
11380
11381 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11382 PyObject *resultobj = 0;
11383 wxString *arg1 = 0 ;
11384 PyObject *arg2 = (PyObject *) 0 ;
11385 bool temp1 = false ;
11386 PyObject * obj0 = 0 ;
11387 PyObject * obj1 = 0 ;
11388 char * kwnames[] = {
11389 (char *) "filename",(char *) "data", NULL
11390 };
11391
11392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11393 {
11394 arg1 = wxString_in_helper(obj0);
11395 if (arg1 == NULL) SWIG_fail;
11396 temp1 = true;
11397 }
11398 arg2 = obj1;
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 resultobj = SWIG_Py_Void();
11406 {
11407 if (temp1)
11408 delete arg1;
11409 }
11410 return resultobj;
11411 fail:
11412 {
11413 if (temp1)
11414 delete arg1;
11415 }
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *resultobj = 0;
11422 wxMemoryFSHandler *result = 0 ;
11423
11424 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11439 PyObject *resultobj = 0;
11440 wxString *arg1 = 0 ;
11441 bool temp1 = false ;
11442 PyObject * obj0 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 {
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 {
11461 if (temp1)
11462 delete arg1;
11463 }
11464 return resultobj;
11465 fail:
11466 {
11467 if (temp1)
11468 delete arg1;
11469 }
11470 return NULL;
11471 }
11472
11473
11474 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11475 PyObject *resultobj = 0;
11476 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11477 wxString *arg2 = 0 ;
11478 bool result;
11479 void *argp1 = 0 ;
11480 int res1 = 0 ;
11481 bool temp2 = false ;
11482 PyObject * obj0 = 0 ;
11483 PyObject * obj1 = 0 ;
11484 char * kwnames[] = {
11485 (char *) "self",(char *) "location", NULL
11486 };
11487
11488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11490 if (!SWIG_IsOK(res1)) {
11491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11492 }
11493 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11494 {
11495 arg2 = wxString_in_helper(obj1);
11496 if (arg2 == NULL) SWIG_fail;
11497 temp2 = true;
11498 }
11499 {
11500 PyThreadState* __tstate = wxPyBeginAllowThreads();
11501 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11502 wxPyEndAllowThreads(__tstate);
11503 if (PyErr_Occurred()) SWIG_fail;
11504 }
11505 {
11506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11507 }
11508 {
11509 if (temp2)
11510 delete arg2;
11511 }
11512 return resultobj;
11513 fail:
11514 {
11515 if (temp2)
11516 delete arg2;
11517 }
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11525 wxFileSystem *arg2 = 0 ;
11526 wxString *arg3 = 0 ;
11527 wxFSFile *result = 0 ;
11528 void *argp1 = 0 ;
11529 int res1 = 0 ;
11530 void *argp2 = 0 ;
11531 int res2 = 0 ;
11532 bool temp3 = false ;
11533 PyObject * obj0 = 0 ;
11534 PyObject * obj1 = 0 ;
11535 PyObject * obj2 = 0 ;
11536 char * kwnames[] = {
11537 (char *) "self",(char *) "fs",(char *) "location", NULL
11538 };
11539
11540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11542 if (!SWIG_IsOK(res1)) {
11543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11544 }
11545 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11547 if (!SWIG_IsOK(res2)) {
11548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11549 }
11550 if (!argp2) {
11551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11552 }
11553 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11554 {
11555 arg3 = wxString_in_helper(obj2);
11556 if (arg3 == NULL) SWIG_fail;
11557 temp3 = true;
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 {
11566 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11567 }
11568 {
11569 if (temp3)
11570 delete arg3;
11571 }
11572 return resultobj;
11573 fail:
11574 {
11575 if (temp3)
11576 delete arg3;
11577 }
11578 return NULL;
11579 }
11580
11581
11582 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11583 PyObject *resultobj = 0;
11584 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11585 wxString *arg2 = 0 ;
11586 int arg3 = (int) 0 ;
11587 wxString result;
11588 void *argp1 = 0 ;
11589 int res1 = 0 ;
11590 bool temp2 = false ;
11591 int val3 ;
11592 int ecode3 = 0 ;
11593 PyObject * obj0 = 0 ;
11594 PyObject * obj1 = 0 ;
11595 PyObject * obj2 = 0 ;
11596 char * kwnames[] = {
11597 (char *) "self",(char *) "spec",(char *) "flags", NULL
11598 };
11599
11600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11604 }
11605 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11606 {
11607 arg2 = wxString_in_helper(obj1);
11608 if (arg2 == NULL) SWIG_fail;
11609 temp2 = true;
11610 }
11611 if (obj2) {
11612 ecode3 = SWIG_AsVal_int(obj2, &val3);
11613 if (!SWIG_IsOK(ecode3)) {
11614 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11615 }
11616 arg3 = static_cast< int >(val3);
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 #if wxUSE_UNICODE
11626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11627 #else
11628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11629 #endif
11630 }
11631 {
11632 if (temp2)
11633 delete arg2;
11634 }
11635 return resultobj;
11636 fail:
11637 {
11638 if (temp2)
11639 delete arg2;
11640 }
11641 return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 PyObject *resultobj = 0;
11647 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11648 wxString result;
11649 void *argp1 = 0 ;
11650 int res1 = 0 ;
11651 PyObject *swig_obj[1] ;
11652
11653 if (!args) SWIG_fail;
11654 swig_obj[0] = args;
11655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11656 if (!SWIG_IsOK(res1)) {
11657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11658 }
11659 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (arg1)->FindNext();
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 #if wxUSE_UNICODE
11668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11669 #else
11670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11671 #endif
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *obj;
11681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11682 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11683 return SWIG_Py_Void();
11684 }
11685
11686 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11687 return SWIG_Python_InitShadowInstance(args);
11688 }
11689
11690 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11691 PyObject *resultobj = 0;
11692 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11693 wxString result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 PyObject *swig_obj[1] ;
11697
11698 if (!args) SWIG_fail;
11699 swig_obj[0] = args;
11700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11701 if (!SWIG_IsOK(res1)) {
11702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11703 }
11704 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (arg1)->GetName();
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 {
11712 #if wxUSE_UNICODE
11713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11714 #else
11715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11716 #endif
11717 }
11718 return resultobj;
11719 fail:
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11725 PyObject *resultobj = 0;
11726 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11727 wxString result;
11728 void *argp1 = 0 ;
11729 int res1 = 0 ;
11730 PyObject *swig_obj[1] ;
11731
11732 if (!args) SWIG_fail;
11733 swig_obj[0] = args;
11734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11737 }
11738 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11739 {
11740 PyThreadState* __tstate = wxPyBeginAllowThreads();
11741 result = (arg1)->GetExtension();
11742 wxPyEndAllowThreads(__tstate);
11743 if (PyErr_Occurred()) SWIG_fail;
11744 }
11745 {
11746 #if wxUSE_UNICODE
11747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11748 #else
11749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11750 #endif
11751 }
11752 return resultobj;
11753 fail:
11754 return NULL;
11755 }
11756
11757
11758 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11759 PyObject *resultobj = 0;
11760 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11761 long result;
11762 void *argp1 = 0 ;
11763 int res1 = 0 ;
11764 PyObject *swig_obj[1] ;
11765
11766 if (!args) SWIG_fail;
11767 swig_obj[0] = args;
11768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11769 if (!SWIG_IsOK(res1)) {
11770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11771 }
11772 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (long)(arg1)->GetType();
11776 wxPyEndAllowThreads(__tstate);
11777 if (PyErr_Occurred()) SWIG_fail;
11778 }
11779 resultobj = SWIG_From_long(static_cast< long >(result));
11780 return resultobj;
11781 fail:
11782 return NULL;
11783 }
11784
11785
11786 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11787 PyObject *resultobj = 0;
11788 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11789 wxString result;
11790 void *argp1 = 0 ;
11791 int res1 = 0 ;
11792 PyObject *swig_obj[1] ;
11793
11794 if (!args) SWIG_fail;
11795 swig_obj[0] = args;
11796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11799 }
11800 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (arg1)->GetMimeType();
11804 wxPyEndAllowThreads(__tstate);
11805 if (PyErr_Occurred()) SWIG_fail;
11806 }
11807 {
11808 #if wxUSE_UNICODE
11809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11810 #else
11811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11812 #endif
11813 }
11814 return resultobj;
11815 fail:
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11821 PyObject *resultobj = 0;
11822 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11823 wxString *arg2 = 0 ;
11824 bool result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 bool temp2 = false ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char * kwnames[] = {
11831 (char *) "self",(char *) "name", NULL
11832 };
11833
11834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11836 if (!SWIG_IsOK(res1)) {
11837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11838 }
11839 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11840 {
11841 arg2 = wxString_in_helper(obj1);
11842 if (arg2 == NULL) SWIG_fail;
11843 temp2 = true;
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11853 }
11854 {
11855 if (temp2)
11856 delete arg2;
11857 }
11858 return resultobj;
11859 fail:
11860 {
11861 if (temp2)
11862 delete arg2;
11863 }
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11871 wxInputStream *arg2 = 0 ;
11872 bool result;
11873 void *argp1 = 0 ;
11874 int res1 = 0 ;
11875 wxPyInputStream *temp2 ;
11876 bool created2 ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 char * kwnames[] = {
11880 (char *) "self",(char *) "stream", NULL
11881 };
11882
11883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11885 if (!SWIG_IsOK(res1)) {
11886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11887 }
11888 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11889 {
11890 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11891 arg2 = temp2->m_wxis;
11892 created2 = false;
11893 } else {
11894 PyErr_Clear(); // clear the failure of the wxPyConvert above
11895 arg2 = wxPyCBInputStream_create(obj1, false);
11896 if (arg2 == NULL) {
11897 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11898 SWIG_fail;
11899 }
11900 created2 = true;
11901 }
11902 }
11903 {
11904 PyThreadState* __tstate = wxPyBeginAllowThreads();
11905 result = (bool)(arg1)->CanRead(*arg2);
11906 wxPyEndAllowThreads(__tstate);
11907 if (PyErr_Occurred()) SWIG_fail;
11908 }
11909 {
11910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11911 }
11912 {
11913 if (created2) delete arg2;
11914 }
11915 return resultobj;
11916 fail:
11917 {
11918 if (created2) delete arg2;
11919 }
11920 return NULL;
11921 }
11922
11923
11924 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj = 0;
11926 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11927 wxString *arg2 = 0 ;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 bool temp2 = false ;
11931 PyObject * obj0 = 0 ;
11932 PyObject * obj1 = 0 ;
11933 char * kwnames[] = {
11934 (char *) "self",(char *) "name", NULL
11935 };
11936
11937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11939 if (!SWIG_IsOK(res1)) {
11940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11941 }
11942 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11943 {
11944 arg2 = wxString_in_helper(obj1);
11945 if (arg2 == NULL) SWIG_fail;
11946 temp2 = true;
11947 }
11948 {
11949 PyThreadState* __tstate = wxPyBeginAllowThreads();
11950 (arg1)->SetName((wxString const &)*arg2);
11951 wxPyEndAllowThreads(__tstate);
11952 if (PyErr_Occurred()) SWIG_fail;
11953 }
11954 resultobj = SWIG_Py_Void();
11955 {
11956 if (temp2)
11957 delete arg2;
11958 }
11959 return resultobj;
11960 fail:
11961 {
11962 if (temp2)
11963 delete arg2;
11964 }
11965 return NULL;
11966 }
11967
11968
11969 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11970 PyObject *resultobj = 0;
11971 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11972 wxString *arg2 = 0 ;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975 bool temp2 = false ;
11976 PyObject * obj0 = 0 ;
11977 PyObject * obj1 = 0 ;
11978 char * kwnames[] = {
11979 (char *) "self",(char *) "extension", NULL
11980 };
11981
11982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11984 if (!SWIG_IsOK(res1)) {
11985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11986 }
11987 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11988 {
11989 arg2 = wxString_in_helper(obj1);
11990 if (arg2 == NULL) SWIG_fail;
11991 temp2 = true;
11992 }
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 (arg1)->SetExtension((wxString const &)*arg2);
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 resultobj = SWIG_Py_Void();
12000 {
12001 if (temp2)
12002 delete arg2;
12003 }
12004 return resultobj;
12005 fail:
12006 {
12007 if (temp2)
12008 delete arg2;
12009 }
12010 return NULL;
12011 }
12012
12013
12014 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12015 PyObject *resultobj = 0;
12016 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12017 long arg2 ;
12018 void *argp1 = 0 ;
12019 int res1 = 0 ;
12020 long val2 ;
12021 int ecode2 = 0 ;
12022 PyObject * obj0 = 0 ;
12023 PyObject * obj1 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "self",(char *) "type", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12030 if (!SWIG_IsOK(res1)) {
12031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12032 }
12033 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12034 ecode2 = SWIG_AsVal_long(obj1, &val2);
12035 if (!SWIG_IsOK(ecode2)) {
12036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12037 }
12038 arg2 = static_cast< long >(val2);
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 (arg1)->SetType(arg2);
12042 wxPyEndAllowThreads(__tstate);
12043 if (PyErr_Occurred()) SWIG_fail;
12044 }
12045 resultobj = SWIG_Py_Void();
12046 return resultobj;
12047 fail:
12048 return NULL;
12049 }
12050
12051
12052 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12053 PyObject *resultobj = 0;
12054 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12055 wxString *arg2 = 0 ;
12056 void *argp1 = 0 ;
12057 int res1 = 0 ;
12058 bool temp2 = false ;
12059 PyObject * obj0 = 0 ;
12060 PyObject * obj1 = 0 ;
12061 char * kwnames[] = {
12062 (char *) "self",(char *) "mimetype", NULL
12063 };
12064
12065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12069 }
12070 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12071 {
12072 arg2 = wxString_in_helper(obj1);
12073 if (arg2 == NULL) SWIG_fail;
12074 temp2 = true;
12075 }
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 (arg1)->SetMimeType((wxString const &)*arg2);
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_Py_Void();
12083 {
12084 if (temp2)
12085 delete arg2;
12086 }
12087 return resultobj;
12088 fail:
12089 {
12090 if (temp2)
12091 delete arg2;
12092 }
12093 return NULL;
12094 }
12095
12096
12097 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12098 PyObject *obj;
12099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12100 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12101 return SWIG_Py_Void();
12102 }
12103
12104 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12105 PyObject *resultobj = 0;
12106 wxPyImageHandler *result = 0 ;
12107
12108 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12109 {
12110 PyThreadState* __tstate = wxPyBeginAllowThreads();
12111 result = (wxPyImageHandler *)new wxPyImageHandler();
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12116 return resultobj;
12117 fail:
12118 return NULL;
12119 }
12120
12121
12122 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12123 PyObject *resultobj = 0;
12124 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12125 PyObject *arg2 = (PyObject *) 0 ;
12126 void *argp1 = 0 ;
12127 int res1 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "self",(char *) "self", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12138 }
12139 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12140 arg2 = obj1;
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 (arg1)->_SetSelf(arg2);
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 resultobj = SWIG_Py_Void();
12148 return resultobj;
12149 fail:
12150 return NULL;
12151 }
12152
12153
12154 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12155 PyObject *obj;
12156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12157 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12158 return SWIG_Py_Void();
12159 }
12160
12161 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12162 return SWIG_Python_InitShadowInstance(args);
12163 }
12164
12165 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12166 PyObject *resultobj = 0;
12167 wxImageHistogram *result = 0 ;
12168
12169 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12170 {
12171 PyThreadState* __tstate = wxPyBeginAllowThreads();
12172 result = (wxImageHistogram *)new wxImageHistogram();
12173 wxPyEndAllowThreads(__tstate);
12174 if (PyErr_Occurred()) SWIG_fail;
12175 }
12176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12177 return resultobj;
12178 fail:
12179 return NULL;
12180 }
12181
12182
12183 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12184 PyObject *resultobj = 0;
12185 byte arg1 ;
12186 byte arg2 ;
12187 byte arg3 ;
12188 unsigned long result;
12189 unsigned char val1 ;
12190 int ecode1 = 0 ;
12191 unsigned char val2 ;
12192 int ecode2 = 0 ;
12193 unsigned char val3 ;
12194 int ecode3 = 0 ;
12195 PyObject * obj0 = 0 ;
12196 PyObject * obj1 = 0 ;
12197 PyObject * obj2 = 0 ;
12198 char * kwnames[] = {
12199 (char *) "r",(char *) "g",(char *) "b", NULL
12200 };
12201
12202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12203 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12204 if (!SWIG_IsOK(ecode1)) {
12205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12206 }
12207 arg1 = static_cast< byte >(val1);
12208 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12209 if (!SWIG_IsOK(ecode2)) {
12210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12211 }
12212 arg2 = static_cast< byte >(val2);
12213 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12214 if (!SWIG_IsOK(ecode3)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12216 }
12217 arg3 = static_cast< byte >(val3);
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12234 byte *arg2 = (byte *) 0 ;
12235 byte *arg3 = (byte *) 0 ;
12236 byte *arg4 = (byte *) 0 ;
12237 byte arg5 = (byte) 1 ;
12238 byte arg6 = (byte) 0 ;
12239 byte arg7 = (byte) 0 ;
12240 bool result;
12241 void *argp1 = 0 ;
12242 int res1 = 0 ;
12243 byte temp2 ;
12244 int res2 = SWIG_TMPOBJ ;
12245 byte temp3 ;
12246 int res3 = SWIG_TMPOBJ ;
12247 byte temp4 ;
12248 int res4 = SWIG_TMPOBJ ;
12249 unsigned char val5 ;
12250 int ecode5 = 0 ;
12251 unsigned char val6 ;
12252 int ecode6 = 0 ;
12253 unsigned char val7 ;
12254 int ecode7 = 0 ;
12255 PyObject * obj0 = 0 ;
12256 PyObject * obj1 = 0 ;
12257 PyObject * obj2 = 0 ;
12258 PyObject * obj3 = 0 ;
12259 char * kwnames[] = {
12260 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12261 };
12262
12263 arg2 = &temp2;
12264 arg3 = &temp3;
12265 arg4 = &temp4;
12266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12268 if (!SWIG_IsOK(res1)) {
12269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12270 }
12271 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12272 if (obj1) {
12273 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12274 if (!SWIG_IsOK(ecode5)) {
12275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12276 }
12277 arg5 = static_cast< byte >(val5);
12278 }
12279 if (obj2) {
12280 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12281 if (!SWIG_IsOK(ecode6)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12283 }
12284 arg6 = static_cast< byte >(val6);
12285 }
12286 if (obj3) {
12287 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12288 if (!SWIG_IsOK(ecode7)) {
12289 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12290 }
12291 arg7 = static_cast< byte >(val7);
12292 }
12293 {
12294 PyThreadState* __tstate = wxPyBeginAllowThreads();
12295 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 {
12300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12301 }
12302 if (SWIG_IsTmpObj(res2)) {
12303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12304 } else {
12305 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12307 }
12308 if (SWIG_IsTmpObj(res3)) {
12309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12310 } else {
12311 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12313 }
12314 if (SWIG_IsTmpObj(res4)) {
12315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12316 } else {
12317 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12327 PyObject *resultobj = 0;
12328 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12329 unsigned long arg2 ;
12330 unsigned long result;
12331 void *argp1 = 0 ;
12332 int res1 = 0 ;
12333 unsigned long val2 ;
12334 int ecode2 = 0 ;
12335 PyObject * obj0 = 0 ;
12336 PyObject * obj1 = 0 ;
12337 char * kwnames[] = {
12338 (char *) "self",(char *) "key", NULL
12339 };
12340
12341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12343 if (!SWIG_IsOK(res1)) {
12344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12345 }
12346 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12347 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12348 if (!SWIG_IsOK(ecode2)) {
12349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12350 }
12351 arg2 = static_cast< unsigned long >(val2);
12352 {
12353 PyThreadState* __tstate = wxPyBeginAllowThreads();
12354 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12359 return resultobj;
12360 fail:
12361 return NULL;
12362 }
12363
12364
12365 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12366 PyObject *resultobj = 0;
12367 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12368 byte arg2 ;
12369 byte arg3 ;
12370 byte arg4 ;
12371 unsigned long result;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 unsigned char val2 ;
12375 int ecode2 = 0 ;
12376 unsigned char val3 ;
12377 int ecode3 = 0 ;
12378 unsigned char val4 ;
12379 int ecode4 = 0 ;
12380 PyObject * obj0 = 0 ;
12381 PyObject * obj1 = 0 ;
12382 PyObject * obj2 = 0 ;
12383 PyObject * obj3 = 0 ;
12384 char * kwnames[] = {
12385 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12386 };
12387
12388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12390 if (!SWIG_IsOK(res1)) {
12391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12392 }
12393 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12394 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12395 if (!SWIG_IsOK(ecode2)) {
12396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12397 }
12398 arg2 = static_cast< byte >(val2);
12399 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12400 if (!SWIG_IsOK(ecode3)) {
12401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12402 }
12403 arg3 = static_cast< byte >(val3);
12404 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12405 if (!SWIG_IsOK(ecode4)) {
12406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12407 }
12408 arg4 = static_cast< byte >(val4);
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12416 return resultobj;
12417 fail:
12418 return NULL;
12419 }
12420
12421
12422 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12423 PyObject *resultobj = 0;
12424 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12425 wxColour *arg2 = 0 ;
12426 unsigned long result;
12427 void *argp1 = 0 ;
12428 int res1 = 0 ;
12429 wxColour temp2 ;
12430 PyObject * obj0 = 0 ;
12431 PyObject * obj1 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "self",(char *) "colour", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12440 }
12441 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12442 {
12443 arg2 = &temp2;
12444 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12445 }
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12449 wxPyEndAllowThreads(__tstate);
12450 if (PyErr_Occurred()) SWIG_fail;
12451 }
12452 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12460 PyObject *obj;
12461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12462 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12463 return SWIG_Py_Void();
12464 }
12465
12466 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12467 return SWIG_Python_InitShadowInstance(args);
12468 }
12469
12470 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = 0;
12472 byte arg1 = (byte) 0 ;
12473 byte arg2 = (byte) 0 ;
12474 byte arg3 = (byte) 0 ;
12475 wxImage_RGBValue *result = 0 ;
12476 unsigned char val1 ;
12477 int ecode1 = 0 ;
12478 unsigned char val2 ;
12479 int ecode2 = 0 ;
12480 unsigned char val3 ;
12481 int ecode3 = 0 ;
12482 PyObject * obj0 = 0 ;
12483 PyObject * obj1 = 0 ;
12484 PyObject * obj2 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "r",(char *) "g",(char *) "b", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12490 if (obj0) {
12491 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12492 if (!SWIG_IsOK(ecode1)) {
12493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12494 }
12495 arg1 = static_cast< byte >(val1);
12496 }
12497 if (obj1) {
12498 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12499 if (!SWIG_IsOK(ecode2)) {
12500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12501 }
12502 arg2 = static_cast< byte >(val2);
12503 }
12504 if (obj2) {
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 }
12511 {
12512 PyThreadState* __tstate = wxPyBeginAllowThreads();
12513 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12514 wxPyEndAllowThreads(__tstate);
12515 if (PyErr_Occurred()) SWIG_fail;
12516 }
12517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12525 PyObject *resultobj = 0;
12526 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12527 byte arg2 ;
12528 void *argp1 = 0 ;
12529 int res1 = 0 ;
12530 unsigned char val2 ;
12531 int ecode2 = 0 ;
12532 PyObject *swig_obj[2] ;
12533
12534 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12538 }
12539 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12540 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12541 if (!SWIG_IsOK(ecode2)) {
12542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12543 }
12544 arg2 = static_cast< byte >(val2);
12545 if (arg1) (arg1)->red = arg2;
12546
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *resultobj = 0;
12556 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12557 byte result;
12558 void *argp1 = 0 ;
12559 int res1 = 0 ;
12560 PyObject *swig_obj[1] ;
12561
12562 if (!args) SWIG_fail;
12563 swig_obj[0] = args;
12564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12565 if (!SWIG_IsOK(res1)) {
12566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12567 }
12568 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12569 result = (byte) ((arg1)->red);
12570 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12571 return resultobj;
12572 fail:
12573 return NULL;
12574 }
12575
12576
12577 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12578 PyObject *resultobj = 0;
12579 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12580 byte arg2 ;
12581 void *argp1 = 0 ;
12582 int res1 = 0 ;
12583 unsigned char val2 ;
12584 int ecode2 = 0 ;
12585 PyObject *swig_obj[2] ;
12586
12587 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12589 if (!SWIG_IsOK(res1)) {
12590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12591 }
12592 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12593 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12594 if (!SWIG_IsOK(ecode2)) {
12595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12596 }
12597 arg2 = static_cast< byte >(val2);
12598 if (arg1) (arg1)->green = arg2;
12599
12600 resultobj = SWIG_Py_Void();
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12608 PyObject *resultobj = 0;
12609 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12610 byte result;
12611 void *argp1 = 0 ;
12612 int res1 = 0 ;
12613 PyObject *swig_obj[1] ;
12614
12615 if (!args) SWIG_fail;
12616 swig_obj[0] = args;
12617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12618 if (!SWIG_IsOK(res1)) {
12619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12620 }
12621 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12622 result = (byte) ((arg1)->green);
12623 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_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_blue_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_blue_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_blue_set" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 if (arg1) (arg1)->blue = arg2;
12652
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_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_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12673 }
12674 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12675 result = (byte) ((arg1)->blue);
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 *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *obj;
12685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12686 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12687 return SWIG_Py_Void();
12688 }
12689
12690 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12691 return SWIG_Python_InitShadowInstance(args);
12692 }
12693
12694 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12695 PyObject *resultobj = 0;
12696 double arg1 = (double) 0.0 ;
12697 double arg2 = (double) 0.0 ;
12698 double arg3 = (double) 0.0 ;
12699 wxImage_HSVValue *result = 0 ;
12700 double val1 ;
12701 int ecode1 = 0 ;
12702 double val2 ;
12703 int ecode2 = 0 ;
12704 double val3 ;
12705 int ecode3 = 0 ;
12706 PyObject * obj0 = 0 ;
12707 PyObject * obj1 = 0 ;
12708 PyObject * obj2 = 0 ;
12709 char * kwnames[] = {
12710 (char *) "h",(char *) "s",(char *) "v", NULL
12711 };
12712
12713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12714 if (obj0) {
12715 ecode1 = SWIG_AsVal_double(obj0, &val1);
12716 if (!SWIG_IsOK(ecode1)) {
12717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12718 }
12719 arg1 = static_cast< double >(val1);
12720 }
12721 if (obj1) {
12722 ecode2 = SWIG_AsVal_double(obj1, &val2);
12723 if (!SWIG_IsOK(ecode2)) {
12724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12725 }
12726 arg2 = static_cast< double >(val2);
12727 }
12728 if (obj2) {
12729 ecode3 = SWIG_AsVal_double(obj2, &val3);
12730 if (!SWIG_IsOK(ecode3)) {
12731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12732 }
12733 arg3 = static_cast< double >(val3);
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12742 return resultobj;
12743 fail:
12744 return NULL;
12745 }
12746
12747
12748 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12749 PyObject *resultobj = 0;
12750 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12751 double arg2 ;
12752 void *argp1 = 0 ;
12753 int res1 = 0 ;
12754 double val2 ;
12755 int ecode2 = 0 ;
12756 PyObject *swig_obj[2] ;
12757
12758 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12760 if (!SWIG_IsOK(res1)) {
12761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12762 }
12763 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12764 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12765 if (!SWIG_IsOK(ecode2)) {
12766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12767 }
12768 arg2 = static_cast< double >(val2);
12769 if (arg1) (arg1)->hue = arg2;
12770
12771 resultobj = SWIG_Py_Void();
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12781 double result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 PyObject *swig_obj[1] ;
12785
12786 if (!args) SWIG_fail;
12787 swig_obj[0] = args;
12788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12789 if (!SWIG_IsOK(res1)) {
12790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12791 }
12792 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12793 result = (double) ((arg1)->hue);
12794 resultobj = SWIG_From_double(static_cast< double >(result));
12795 return resultobj;
12796 fail:
12797 return NULL;
12798 }
12799
12800
12801 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12802 PyObject *resultobj = 0;
12803 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12804 double arg2 ;
12805 void *argp1 = 0 ;
12806 int res1 = 0 ;
12807 double val2 ;
12808 int ecode2 = 0 ;
12809 PyObject *swig_obj[2] ;
12810
12811 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12817 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12818 if (!SWIG_IsOK(ecode2)) {
12819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12820 }
12821 arg2 = static_cast< double >(val2);
12822 if (arg1) (arg1)->saturation = arg2;
12823
12824 resultobj = SWIG_Py_Void();
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *resultobj = 0;
12833 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12834 double result;
12835 void *argp1 = 0 ;
12836 int res1 = 0 ;
12837 PyObject *swig_obj[1] ;
12838
12839 if (!args) SWIG_fail;
12840 swig_obj[0] = args;
12841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12842 if (!SWIG_IsOK(res1)) {
12843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12844 }
12845 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12846 result = (double) ((arg1)->saturation);
12847 resultobj = SWIG_From_double(static_cast< double >(result));
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_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_value_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_value_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_value_set" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 if (arg1) (arg1)->value = arg2;
12876
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_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_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12897 }
12898 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12899 result = (double) ((arg1)->value);
12900 resultobj = SWIG_From_double(static_cast< double >(result));
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *obj;
12909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12910 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12911 return SWIG_Py_Void();
12912 }
12913
12914 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12915 return SWIG_Python_InitShadowInstance(args);
12916 }
12917
12918 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj = 0;
12920 wxString *arg1 = 0 ;
12921 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12922 int arg3 = (int) -1 ;
12923 wxImage *result = 0 ;
12924 bool temp1 = false ;
12925 long val2 ;
12926 int ecode2 = 0 ;
12927 int val3 ;
12928 int ecode3 = 0 ;
12929 PyObject * obj0 = 0 ;
12930 PyObject * obj1 = 0 ;
12931 PyObject * obj2 = 0 ;
12932 char * kwnames[] = {
12933 (char *) "name",(char *) "type",(char *) "index", NULL
12934 };
12935
12936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12937 {
12938 arg1 = wxString_in_helper(obj0);
12939 if (arg1 == NULL) SWIG_fail;
12940 temp1 = true;
12941 }
12942 if (obj1) {
12943 ecode2 = SWIG_AsVal_long(obj1, &val2);
12944 if (!SWIG_IsOK(ecode2)) {
12945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12946 }
12947 arg2 = static_cast< long >(val2);
12948 }
12949 if (obj2) {
12950 ecode3 = SWIG_AsVal_int(obj2, &val3);
12951 if (!SWIG_IsOK(ecode3)) {
12952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12953 }
12954 arg3 = static_cast< int >(val3);
12955 }
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12963 {
12964 if (temp1)
12965 delete arg1;
12966 }
12967 return resultobj;
12968 fail:
12969 {
12970 if (temp1)
12971 delete arg1;
12972 }
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxImage *arg1 = (wxImage *) 0 ;
12980 void *argp1 = 0 ;
12981 int res1 = 0 ;
12982 PyObject *swig_obj[1] ;
12983
12984 if (!args) SWIG_fail;
12985 swig_obj[0] = args;
12986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12989 }
12990 arg1 = reinterpret_cast< wxImage * >(argp1);
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 delete arg1;
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 resultobj = SWIG_Py_Void();
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj = 0;
13007 wxString *arg1 = 0 ;
13008 wxString *arg2 = 0 ;
13009 int arg3 = (int) -1 ;
13010 wxImage *result = 0 ;
13011 bool temp1 = false ;
13012 bool temp2 = false ;
13013 int val3 ;
13014 int ecode3 = 0 ;
13015 PyObject * obj0 = 0 ;
13016 PyObject * obj1 = 0 ;
13017 PyObject * obj2 = 0 ;
13018 char * kwnames[] = {
13019 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13020 };
13021
13022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13023 {
13024 arg1 = wxString_in_helper(obj0);
13025 if (arg1 == NULL) SWIG_fail;
13026 temp1 = true;
13027 }
13028 {
13029 arg2 = wxString_in_helper(obj1);
13030 if (arg2 == NULL) SWIG_fail;
13031 temp2 = true;
13032 }
13033 if (obj2) {
13034 ecode3 = SWIG_AsVal_int(obj2, &val3);
13035 if (!SWIG_IsOK(ecode3)) {
13036 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13037 }
13038 arg3 = static_cast< int >(val3);
13039 }
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13047 {
13048 if (temp1)
13049 delete arg1;
13050 }
13051 {
13052 if (temp2)
13053 delete arg2;
13054 }
13055 return resultobj;
13056 fail:
13057 {
13058 if (temp1)
13059 delete arg1;
13060 }
13061 {
13062 if (temp2)
13063 delete arg2;
13064 }
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = 0;
13071 wxInputStream *arg1 = 0 ;
13072 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13073 int arg3 = (int) -1 ;
13074 wxImage *result = 0 ;
13075 wxPyInputStream *temp1 ;
13076 bool created1 ;
13077 long val2 ;
13078 int ecode2 = 0 ;
13079 int val3 ;
13080 int ecode3 = 0 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 PyObject * obj2 = 0 ;
13084 char * kwnames[] = {
13085 (char *) "stream",(char *) "type",(char *) "index", NULL
13086 };
13087
13088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13089 {
13090 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13091 arg1 = temp1->m_wxis;
13092 created1 = false;
13093 } else {
13094 PyErr_Clear(); // clear the failure of the wxPyConvert above
13095 arg1 = wxPyCBInputStream_create(obj0, false);
13096 if (arg1 == NULL) {
13097 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13098 SWIG_fail;
13099 }
13100 created1 = true;
13101 }
13102 }
13103 if (obj1) {
13104 ecode2 = SWIG_AsVal_long(obj1, &val2);
13105 if (!SWIG_IsOK(ecode2)) {
13106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13107 }
13108 arg2 = static_cast< long >(val2);
13109 }
13110 if (obj2) {
13111 ecode3 = SWIG_AsVal_int(obj2, &val3);
13112 if (!SWIG_IsOK(ecode3)) {
13113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13114 }
13115 arg3 = static_cast< int >(val3);
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13124 {
13125 if (created1) delete arg1;
13126 }
13127 return resultobj;
13128 fail:
13129 {
13130 if (created1) delete arg1;
13131 }
13132 return NULL;
13133 }
13134
13135
13136 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13137 PyObject *resultobj = 0;
13138 wxInputStream *arg1 = 0 ;
13139 wxString *arg2 = 0 ;
13140 int arg3 = (int) -1 ;
13141 wxImage *result = 0 ;
13142 wxPyInputStream *temp1 ;
13143 bool created1 ;
13144 bool temp2 = false ;
13145 int val3 ;
13146 int ecode3 = 0 ;
13147 PyObject * obj0 = 0 ;
13148 PyObject * obj1 = 0 ;
13149 PyObject * obj2 = 0 ;
13150 char * kwnames[] = {
13151 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13152 };
13153
13154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13155 {
13156 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13157 arg1 = temp1->m_wxis;
13158 created1 = false;
13159 } else {
13160 PyErr_Clear(); // clear the failure of the wxPyConvert above
13161 arg1 = wxPyCBInputStream_create(obj0, false);
13162 if (arg1 == NULL) {
13163 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13164 SWIG_fail;
13165 }
13166 created1 = true;
13167 }
13168 }
13169 {
13170 arg2 = wxString_in_helper(obj1);
13171 if (arg2 == NULL) SWIG_fail;
13172 temp2 = true;
13173 }
13174 if (obj2) {
13175 ecode3 = SWIG_AsVal_int(obj2, &val3);
13176 if (!SWIG_IsOK(ecode3)) {
13177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13178 }
13179 arg3 = static_cast< int >(val3);
13180 }
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13184 wxPyEndAllowThreads(__tstate);
13185 if (PyErr_Occurred()) SWIG_fail;
13186 }
13187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13188 {
13189 if (created1) delete arg1;
13190 }
13191 {
13192 if (temp2)
13193 delete arg2;
13194 }
13195 return resultobj;
13196 fail:
13197 {
13198 if (created1) delete arg1;
13199 }
13200 {
13201 if (temp2)
13202 delete arg2;
13203 }
13204 return NULL;
13205 }
13206
13207
13208 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13209 PyObject *resultobj = 0;
13210 int arg1 = (int) 0 ;
13211 int arg2 = (int) 0 ;
13212 bool arg3 = (bool) true ;
13213 wxImage *result = 0 ;
13214 int val1 ;
13215 int ecode1 = 0 ;
13216 int val2 ;
13217 int ecode2 = 0 ;
13218 bool val3 ;
13219 int ecode3 = 0 ;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 PyObject * obj2 = 0 ;
13223 char * kwnames[] = {
13224 (char *) "width",(char *) "height",(char *) "clear", NULL
13225 };
13226
13227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13228 if (obj0) {
13229 ecode1 = SWIG_AsVal_int(obj0, &val1);
13230 if (!SWIG_IsOK(ecode1)) {
13231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13232 }
13233 arg1 = static_cast< int >(val1);
13234 }
13235 if (obj1) {
13236 ecode2 = SWIG_AsVal_int(obj1, &val2);
13237 if (!SWIG_IsOK(ecode2)) {
13238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13239 }
13240 arg2 = static_cast< int >(val2);
13241 }
13242 if (obj2) {
13243 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13244 if (!SWIG_IsOK(ecode3)) {
13245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13246 }
13247 arg3 = static_cast< bool >(val3);
13248 }
13249 {
13250 PyThreadState* __tstate = wxPyBeginAllowThreads();
13251 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13252 wxPyEndAllowThreads(__tstate);
13253 if (PyErr_Occurred()) SWIG_fail;
13254 }
13255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13256 return resultobj;
13257 fail:
13258 return NULL;
13259 }
13260
13261
13262 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13263 PyObject *resultobj = 0;
13264 wxBitmap *arg1 = 0 ;
13265 wxImage *result = 0 ;
13266 void *argp1 = 0 ;
13267 int res1 = 0 ;
13268 PyObject * obj0 = 0 ;
13269 char * kwnames[] = {
13270 (char *) "bitmap", NULL
13271 };
13272
13273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13274 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13275 if (!SWIG_IsOK(res1)) {
13276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13277 }
13278 if (!argp1) {
13279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13280 }
13281 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13282 {
13283 if (!wxPyCheckForApp()) SWIG_fail;
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj = 0;
13298 int arg1 ;
13299 int arg2 ;
13300 buffer arg3 ;
13301 int arg4 ;
13302 wxImage *result = 0 ;
13303 int val1 ;
13304 int ecode1 = 0 ;
13305 int val2 ;
13306 int ecode2 = 0 ;
13307 PyObject * obj0 = 0 ;
13308 PyObject * obj1 = 0 ;
13309 PyObject * obj2 = 0 ;
13310 char * kwnames[] = {
13311 (char *) "width",(char *) "height",(char *) "data", NULL
13312 };
13313
13314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13315 ecode1 = SWIG_AsVal_int(obj0, &val1);
13316 if (!SWIG_IsOK(ecode1)) {
13317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13318 }
13319 arg1 = static_cast< int >(val1);
13320 ecode2 = SWIG_AsVal_int(obj1, &val2);
13321 if (!SWIG_IsOK(ecode2)) {
13322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13323 }
13324 arg2 = static_cast< int >(val2);
13325 {
13326 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13327 }
13328 {
13329 PyThreadState* __tstate = wxPyBeginAllowThreads();
13330 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13331 wxPyEndAllowThreads(__tstate);
13332 if (PyErr_Occurred()) SWIG_fail;
13333 }
13334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13342 PyObject *resultobj = 0;
13343 int arg1 ;
13344 int arg2 ;
13345 buffer arg3 ;
13346 int arg4 ;
13347 buffer arg5 ;
13348 int arg6 ;
13349 wxImage *result = 0 ;
13350 int val1 ;
13351 int ecode1 = 0 ;
13352 int val2 ;
13353 int ecode2 = 0 ;
13354 PyObject * obj0 = 0 ;
13355 PyObject * obj1 = 0 ;
13356 PyObject * obj2 = 0 ;
13357 PyObject * obj3 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13363 ecode1 = SWIG_AsVal_int(obj0, &val1);
13364 if (!SWIG_IsOK(ecode1)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13366 }
13367 arg1 = static_cast< int >(val1);
13368 ecode2 = SWIG_AsVal_int(obj1, &val2);
13369 if (!SWIG_IsOK(ecode2)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13371 }
13372 arg2 = static_cast< int >(val2);
13373 {
13374 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13375 }
13376 {
13377 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13378 }
13379 {
13380 PyThreadState* __tstate = wxPyBeginAllowThreads();
13381 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13386 return resultobj;
13387 fail:
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj = 0;
13394 wxImage *arg1 = (wxImage *) 0 ;
13395 int arg2 ;
13396 int arg3 ;
13397 bool arg4 = (bool) true ;
13398 void *argp1 = 0 ;
13399 int res1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 int val3 ;
13403 int ecode3 = 0 ;
13404 bool val4 ;
13405 int ecode4 = 0 ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 PyObject * obj2 = 0 ;
13409 PyObject * obj3 = 0 ;
13410 char * kwnames[] = {
13411 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13412 };
13413
13414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13418 }
13419 arg1 = reinterpret_cast< wxImage * >(argp1);
13420 ecode2 = SWIG_AsVal_int(obj1, &val2);
13421 if (!SWIG_IsOK(ecode2)) {
13422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13423 }
13424 arg2 = static_cast< int >(val2);
13425 ecode3 = SWIG_AsVal_int(obj2, &val3);
13426 if (!SWIG_IsOK(ecode3)) {
13427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13428 }
13429 arg3 = static_cast< int >(val3);
13430 if (obj3) {
13431 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13432 if (!SWIG_IsOK(ecode4)) {
13433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13434 }
13435 arg4 = static_cast< bool >(val4);
13436 }
13437 {
13438 PyThreadState* __tstate = wxPyBeginAllowThreads();
13439 (arg1)->Create(arg2,arg3,arg4);
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_Py_Void();
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13451 PyObject *resultobj = 0;
13452 wxImage *arg1 = (wxImage *) 0 ;
13453 void *argp1 = 0 ;
13454 int res1 = 0 ;
13455 PyObject *swig_obj[1] ;
13456
13457 if (!args) SWIG_fail;
13458 swig_obj[0] = args;
13459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13460 if (!SWIG_IsOK(res1)) {
13461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13462 }
13463 arg1 = reinterpret_cast< wxImage * >(argp1);
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 (arg1)->Destroy();
13467 wxPyEndAllowThreads(__tstate);
13468 if (PyErr_Occurred()) SWIG_fail;
13469 }
13470 resultobj = SWIG_Py_Void();
13471 return resultobj;
13472 fail:
13473 return NULL;
13474 }
13475
13476
13477 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13478 PyObject *resultobj = 0;
13479 wxImage *arg1 = (wxImage *) 0 ;
13480 int arg2 ;
13481 int arg3 ;
13482 SwigValueWrapper<wxImage > result;
13483 void *argp1 = 0 ;
13484 int res1 = 0 ;
13485 int val2 ;
13486 int ecode2 = 0 ;
13487 int val3 ;
13488 int ecode3 = 0 ;
13489 PyObject * obj0 = 0 ;
13490 PyObject * obj1 = 0 ;
13491 PyObject * obj2 = 0 ;
13492 char * kwnames[] = {
13493 (char *) "self",(char *) "width",(char *) "height", NULL
13494 };
13495
13496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13498 if (!SWIG_IsOK(res1)) {
13499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13500 }
13501 arg1 = reinterpret_cast< wxImage * >(argp1);
13502 ecode2 = SWIG_AsVal_int(obj1, &val2);
13503 if (!SWIG_IsOK(ecode2)) {
13504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13505 }
13506 arg2 = static_cast< int >(val2);
13507 ecode3 = SWIG_AsVal_int(obj2, &val3);
13508 if (!SWIG_IsOK(ecode3)) {
13509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13510 }
13511 arg3 = static_cast< int >(val3);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 result = (arg1)->Scale(arg2,arg3);
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 int arg2 ;
13529 int arg3 ;
13530 SwigValueWrapper<wxImage > result;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 int val2 ;
13534 int ecode2 = 0 ;
13535 int val3 ;
13536 int ecode3 = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13548 }
13549 arg1 = reinterpret_cast< wxImage * >(argp1);
13550 ecode2 = SWIG_AsVal_int(obj1, &val2);
13551 if (!SWIG_IsOK(ecode2)) {
13552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13553 }
13554 arg2 = static_cast< int >(val2);
13555 ecode3 = SWIG_AsVal_int(obj2, &val3);
13556 if (!SWIG_IsOK(ecode3)) {
13557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13558 }
13559 arg3 = static_cast< int >(val3);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 wxImage *result = 0 ;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 PyObject * obj2 = 0 ;
13588 char * kwnames[] = {
13589 (char *) "self",(char *) "width",(char *) "height", NULL
13590 };
13591
13592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13596 }
13597 arg1 = reinterpret_cast< wxImage * >(argp1);
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 ecode3 = SWIG_AsVal_int(obj2, &val3);
13604 if (!SWIG_IsOK(ecode3)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13606 }
13607 arg3 = static_cast< int >(val3);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 {
13611 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13612 result = (wxImage *) &_result_ref;
13613 }
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 wxImage *arg1 = (wxImage *) 0 ;
13627 wxSize *arg2 = 0 ;
13628 wxPoint *arg3 = 0 ;
13629 int arg4 = (int) -1 ;
13630 int arg5 = (int) -1 ;
13631 int arg6 = (int) -1 ;
13632 wxImage *result = 0 ;
13633 void *argp1 = 0 ;
13634 int res1 = 0 ;
13635 wxSize temp2 ;
13636 wxPoint temp3 ;
13637 int val4 ;
13638 int ecode4 = 0 ;
13639 int val5 ;
13640 int ecode5 = 0 ;
13641 int val6 ;
13642 int ecode6 = 0 ;
13643 PyObject * obj0 = 0 ;
13644 PyObject * obj1 = 0 ;
13645 PyObject * obj2 = 0 ;
13646 PyObject * obj3 = 0 ;
13647 PyObject * obj4 = 0 ;
13648 PyObject * obj5 = 0 ;
13649 char * kwnames[] = {
13650 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13655 if (!SWIG_IsOK(res1)) {
13656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 {
13660 arg2 = &temp2;
13661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13662 }
13663 {
13664 arg3 = &temp3;
13665 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13666 }
13667 if (obj3) {
13668 ecode4 = SWIG_AsVal_int(obj3, &val4);
13669 if (!SWIG_IsOK(ecode4)) {
13670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13671 }
13672 arg4 = static_cast< int >(val4);
13673 }
13674 if (obj4) {
13675 ecode5 = SWIG_AsVal_int(obj4, &val5);
13676 if (!SWIG_IsOK(ecode5)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13678 }
13679 arg5 = static_cast< int >(val5);
13680 }
13681 if (obj5) {
13682 ecode6 = SWIG_AsVal_int(obj5, &val6);
13683 if (!SWIG_IsOK(ecode6)) {
13684 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13685 }
13686 arg6 = static_cast< int >(val6);
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 {
13691 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13692 result = (wxImage *) &_result_ref;
13693 }
13694 wxPyEndAllowThreads(__tstate);
13695 if (PyErr_Occurred()) SWIG_fail;
13696 }
13697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13698 return resultobj;
13699 fail:
13700 return NULL;
13701 }
13702
13703
13704 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13705 PyObject *resultobj = 0;
13706 wxImage *arg1 = (wxImage *) 0 ;
13707 int arg2 ;
13708 int arg3 ;
13709 byte arg4 ;
13710 byte arg5 ;
13711 byte arg6 ;
13712 void *argp1 = 0 ;
13713 int res1 = 0 ;
13714 int val2 ;
13715 int ecode2 = 0 ;
13716 int val3 ;
13717 int ecode3 = 0 ;
13718 unsigned char val4 ;
13719 int ecode4 = 0 ;
13720 unsigned char val5 ;
13721 int ecode5 = 0 ;
13722 unsigned char val6 ;
13723 int ecode6 = 0 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 PyObject * obj3 = 0 ;
13728 PyObject * obj4 = 0 ;
13729 PyObject * obj5 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13738 }
13739 arg1 = reinterpret_cast< wxImage * >(argp1);
13740 ecode2 = SWIG_AsVal_int(obj1, &val2);
13741 if (!SWIG_IsOK(ecode2)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13743 }
13744 arg2 = static_cast< int >(val2);
13745 ecode3 = SWIG_AsVal_int(obj2, &val3);
13746 if (!SWIG_IsOK(ecode3)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13748 }
13749 arg3 = static_cast< int >(val3);
13750 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13751 if (!SWIG_IsOK(ecode4)) {
13752 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13753 }
13754 arg4 = static_cast< byte >(val4);
13755 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13756 if (!SWIG_IsOK(ecode5)) {
13757 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13758 }
13759 arg5 = static_cast< byte >(val5);
13760 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13761 if (!SWIG_IsOK(ecode6)) {
13762 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13763 }
13764 arg6 = static_cast< byte >(val6);
13765 {
13766 PyThreadState* __tstate = wxPyBeginAllowThreads();
13767 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13768 wxPyEndAllowThreads(__tstate);
13769 if (PyErr_Occurred()) SWIG_fail;
13770 }
13771 resultobj = SWIG_Py_Void();
13772 return resultobj;
13773 fail:
13774 return NULL;
13775 }
13776
13777
13778 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj = 0;
13780 wxImage *arg1 = (wxImage *) 0 ;
13781 wxRect *arg2 = 0 ;
13782 byte arg3 ;
13783 byte arg4 ;
13784 byte arg5 ;
13785 void *argp1 = 0 ;
13786 int res1 = 0 ;
13787 wxRect temp2 ;
13788 unsigned char val3 ;
13789 int ecode3 = 0 ;
13790 unsigned char val4 ;
13791 int ecode4 = 0 ;
13792 unsigned char val5 ;
13793 int ecode5 = 0 ;
13794 PyObject * obj0 = 0 ;
13795 PyObject * obj1 = 0 ;
13796 PyObject * obj2 = 0 ;
13797 PyObject * obj3 = 0 ;
13798 PyObject * obj4 = 0 ;
13799 char * kwnames[] = {
13800 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13801 };
13802
13803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13805 if (!SWIG_IsOK(res1)) {
13806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13807 }
13808 arg1 = reinterpret_cast< wxImage * >(argp1);
13809 {
13810 arg2 = &temp2;
13811 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13812 }
13813 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13814 if (!SWIG_IsOK(ecode3)) {
13815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13816 }
13817 arg3 = static_cast< byte >(val3);
13818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13819 if (!SWIG_IsOK(ecode4)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13821 }
13822 arg4 = static_cast< byte >(val4);
13823 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13824 if (!SWIG_IsOK(ecode5)) {
13825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13826 }
13827 arg5 = static_cast< byte >(val5);
13828 {
13829 PyThreadState* __tstate = wxPyBeginAllowThreads();
13830 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13831 wxPyEndAllowThreads(__tstate);
13832 if (PyErr_Occurred()) SWIG_fail;
13833 }
13834 resultobj = SWIG_Py_Void();
13835 return resultobj;
13836 fail:
13837 return NULL;
13838 }
13839
13840
13841 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13842 PyObject *resultobj = 0;
13843 wxImage *arg1 = (wxImage *) 0 ;
13844 int arg2 ;
13845 int arg3 ;
13846 byte result;
13847 void *argp1 = 0 ;
13848 int res1 = 0 ;
13849 int val2 ;
13850 int ecode2 = 0 ;
13851 int val3 ;
13852 int ecode3 = 0 ;
13853 PyObject * obj0 = 0 ;
13854 PyObject * obj1 = 0 ;
13855 PyObject * obj2 = 0 ;
13856 char * kwnames[] = {
13857 (char *) "self",(char *) "x",(char *) "y", NULL
13858 };
13859
13860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13862 if (!SWIG_IsOK(res1)) {
13863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13864 }
13865 arg1 = reinterpret_cast< wxImage * >(argp1);
13866 ecode2 = SWIG_AsVal_int(obj1, &val2);
13867 if (!SWIG_IsOK(ecode2)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13869 }
13870 arg2 = static_cast< int >(val2);
13871 ecode3 = SWIG_AsVal_int(obj2, &val3);
13872 if (!SWIG_IsOK(ecode3)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13874 }
13875 arg3 = static_cast< int >(val3);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 result = (byte)(arg1)->GetRed(arg2,arg3);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxImage *arg1 = (wxImage *) 0 ;
13892 int arg2 ;
13893 int arg3 ;
13894 byte result;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 int val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (byte)(arg1)->GetGreen(arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj = 0;
13939 wxImage *arg1 = (wxImage *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 byte result;
13943 void *argp1 = 0 ;
13944 int res1 = 0 ;
13945 int val2 ;
13946 int ecode2 = 0 ;
13947 int val3 ;
13948 int ecode3 = 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 PyObject * obj2 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "self",(char *) "x",(char *) "y", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13960 }
13961 arg1 = reinterpret_cast< wxImage * >(argp1);
13962 ecode2 = SWIG_AsVal_int(obj1, &val2);
13963 if (!SWIG_IsOK(ecode2)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13965 }
13966 arg2 = static_cast< int >(val2);
13967 ecode3 = SWIG_AsVal_int(obj2, &val3);
13968 if (!SWIG_IsOK(ecode3)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13970 }
13971 arg3 = static_cast< int >(val3);
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 result = (byte)(arg1)->GetBlue(arg2,arg3);
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = 0;
13987 wxImage *arg1 = (wxImage *) 0 ;
13988 int arg2 ;
13989 int arg3 ;
13990 byte arg4 ;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 int val2 ;
13994 int ecode2 = 0 ;
13995 int val3 ;
13996 int ecode3 = 0 ;
13997 unsigned char val4 ;
13998 int ecode4 = 0 ;
13999 PyObject * obj0 = 0 ;
14000 PyObject * obj1 = 0 ;
14001 PyObject * obj2 = 0 ;
14002 PyObject * obj3 = 0 ;
14003 char * kwnames[] = {
14004 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14005 };
14006
14007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14009 if (!SWIG_IsOK(res1)) {
14010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14011 }
14012 arg1 = reinterpret_cast< wxImage * >(argp1);
14013 ecode2 = SWIG_AsVal_int(obj1, &val2);
14014 if (!SWIG_IsOK(ecode2)) {
14015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14016 }
14017 arg2 = static_cast< int >(val2);
14018 ecode3 = SWIG_AsVal_int(obj2, &val3);
14019 if (!SWIG_IsOK(ecode3)) {
14020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14021 }
14022 arg3 = static_cast< int >(val3);
14023 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14024 if (!SWIG_IsOK(ecode4)) {
14025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14026 }
14027 arg4 = static_cast< byte >(val4);
14028 {
14029 PyThreadState* __tstate = wxPyBeginAllowThreads();
14030 (arg1)->SetAlpha(arg2,arg3,arg4);
14031 wxPyEndAllowThreads(__tstate);
14032 if (PyErr_Occurred()) SWIG_fail;
14033 }
14034 resultobj = SWIG_Py_Void();
14035 return resultobj;
14036 fail:
14037 return NULL;
14038 }
14039
14040
14041 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14042 PyObject *resultobj = 0;
14043 wxImage *arg1 = (wxImage *) 0 ;
14044 int arg2 ;
14045 int arg3 ;
14046 byte result;
14047 void *argp1 = 0 ;
14048 int res1 = 0 ;
14049 int val2 ;
14050 int ecode2 = 0 ;
14051 int val3 ;
14052 int ecode3 = 0 ;
14053 PyObject * obj0 = 0 ;
14054 PyObject * obj1 = 0 ;
14055 PyObject * obj2 = 0 ;
14056 char * kwnames[] = {
14057 (char *) "self",(char *) "x",(char *) "y", NULL
14058 };
14059
14060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14064 }
14065 arg1 = reinterpret_cast< wxImage * >(argp1);
14066 ecode2 = SWIG_AsVal_int(obj1, &val2);
14067 if (!SWIG_IsOK(ecode2)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14069 }
14070 arg2 = static_cast< int >(val2);
14071 ecode3 = SWIG_AsVal_int(obj2, &val3);
14072 if (!SWIG_IsOK(ecode3)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14074 }
14075 arg3 = static_cast< int >(val3);
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14090 PyObject *resultobj = 0;
14091 wxImage *arg1 = (wxImage *) 0 ;
14092 bool result;
14093 void *argp1 = 0 ;
14094 int res1 = 0 ;
14095 PyObject *swig_obj[1] ;
14096
14097 if (!args) SWIG_fail;
14098 swig_obj[0] = args;
14099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14100 if (!SWIG_IsOK(res1)) {
14101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14102 }
14103 arg1 = reinterpret_cast< wxImage * >(argp1);
14104 {
14105 PyThreadState* __tstate = wxPyBeginAllowThreads();
14106 result = (bool)(arg1)->HasAlpha();
14107 wxPyEndAllowThreads(__tstate);
14108 if (PyErr_Occurred()) SWIG_fail;
14109 }
14110 {
14111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14112 }
14113 return resultobj;
14114 fail:
14115 return NULL;
14116 }
14117
14118
14119 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14120 PyObject *resultobj = 0;
14121 wxImage *arg1 = (wxImage *) 0 ;
14122 void *argp1 = 0 ;
14123 int res1 = 0 ;
14124 PyObject *swig_obj[1] ;
14125
14126 if (!args) SWIG_fail;
14127 swig_obj[0] = args;
14128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14129 if (!SWIG_IsOK(res1)) {
14130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14131 }
14132 arg1 = reinterpret_cast< wxImage * >(argp1);
14133 {
14134 PyThreadState* __tstate = wxPyBeginAllowThreads();
14135 (arg1)->InitAlpha();
14136 wxPyEndAllowThreads(__tstate);
14137 if (PyErr_Occurred()) SWIG_fail;
14138 }
14139 resultobj = SWIG_Py_Void();
14140 return resultobj;
14141 fail:
14142 return NULL;
14143 }
14144
14145
14146 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14147 PyObject *resultobj = 0;
14148 wxImage *arg1 = (wxImage *) 0 ;
14149 int arg2 ;
14150 int arg3 ;
14151 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14152 bool result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 int val2 ;
14156 int ecode2 = 0 ;
14157 int val3 ;
14158 int ecode3 = 0 ;
14159 unsigned char val4 ;
14160 int ecode4 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 PyObject * obj3 = 0 ;
14165 char * kwnames[] = {
14166 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14167 };
14168
14169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14171 if (!SWIG_IsOK(res1)) {
14172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14173 }
14174 arg1 = reinterpret_cast< wxImage * >(argp1);
14175 ecode2 = SWIG_AsVal_int(obj1, &val2);
14176 if (!SWIG_IsOK(ecode2)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14178 }
14179 arg2 = static_cast< int >(val2);
14180 ecode3 = SWIG_AsVal_int(obj2, &val3);
14181 if (!SWIG_IsOK(ecode3)) {
14182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14183 }
14184 arg3 = static_cast< int >(val3);
14185 if (obj3) {
14186 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14187 if (!SWIG_IsOK(ecode4)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14189 }
14190 arg4 = static_cast< byte >(val4);
14191 }
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 {
14199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14200 }
14201 return resultobj;
14202 fail:
14203 return NULL;
14204 }
14205
14206
14207 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14208 PyObject *resultobj = 0;
14209 wxImage *arg1 = (wxImage *) 0 ;
14210 byte *arg2 = (byte *) 0 ;
14211 byte *arg3 = (byte *) 0 ;
14212 byte *arg4 = (byte *) 0 ;
14213 byte arg5 = (byte) 0 ;
14214 byte arg6 = (byte) 0 ;
14215 byte arg7 = (byte) 0 ;
14216 bool result;
14217 void *argp1 = 0 ;
14218 int res1 = 0 ;
14219 byte temp2 ;
14220 int res2 = SWIG_TMPOBJ ;
14221 byte temp3 ;
14222 int res3 = SWIG_TMPOBJ ;
14223 byte temp4 ;
14224 int res4 = SWIG_TMPOBJ ;
14225 unsigned char val5 ;
14226 int ecode5 = 0 ;
14227 unsigned char val6 ;
14228 int ecode6 = 0 ;
14229 unsigned char val7 ;
14230 int ecode7 = 0 ;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 PyObject * obj2 = 0 ;
14234 PyObject * obj3 = 0 ;
14235 char * kwnames[] = {
14236 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14237 };
14238
14239 arg2 = &temp2;
14240 arg3 = &temp3;
14241 arg4 = &temp4;
14242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14244 if (!SWIG_IsOK(res1)) {
14245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14246 }
14247 arg1 = reinterpret_cast< wxImage * >(argp1);
14248 if (obj1) {
14249 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14250 if (!SWIG_IsOK(ecode5)) {
14251 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14252 }
14253 arg5 = static_cast< byte >(val5);
14254 }
14255 if (obj2) {
14256 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14257 if (!SWIG_IsOK(ecode6)) {
14258 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14259 }
14260 arg6 = static_cast< byte >(val6);
14261 }
14262 if (obj3) {
14263 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14264 if (!SWIG_IsOK(ecode7)) {
14265 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14266 }
14267 arg7 = static_cast< byte >(val7);
14268 }
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14272 wxPyEndAllowThreads(__tstate);
14273 if (PyErr_Occurred()) SWIG_fail;
14274 }
14275 {
14276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14277 }
14278 if (SWIG_IsTmpObj(res2)) {
14279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14280 } else {
14281 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14283 }
14284 if (SWIG_IsTmpObj(res3)) {
14285 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14286 } else {
14287 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14289 }
14290 if (SWIG_IsTmpObj(res4)) {
14291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14292 } else {
14293 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14295 }
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj = 0;
14304 wxImage *arg1 = (wxImage *) 0 ;
14305 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14306 bool result;
14307 void *argp1 = 0 ;
14308 int res1 = 0 ;
14309 unsigned char val2 ;
14310 int ecode2 = 0 ;
14311 PyObject * obj0 = 0 ;
14312 PyObject * obj1 = 0 ;
14313 char * kwnames[] = {
14314 (char *) "self",(char *) "threshold", NULL
14315 };
14316
14317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14319 if (!SWIG_IsOK(res1)) {
14320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14321 }
14322 arg1 = reinterpret_cast< wxImage * >(argp1);
14323 if (obj1) {
14324 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14325 if (!SWIG_IsOK(ecode2)) {
14326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14327 }
14328 arg2 = static_cast< byte >(val2);
14329 }
14330 {
14331 PyThreadState* __tstate = wxPyBeginAllowThreads();
14332 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14333 wxPyEndAllowThreads(__tstate);
14334 if (PyErr_Occurred()) SWIG_fail;
14335 }
14336 {
14337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14338 }
14339 return resultobj;
14340 fail:
14341 return NULL;
14342 }
14343
14344
14345 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14346 PyObject *resultobj = 0;
14347 wxImage *arg1 = (wxImage *) 0 ;
14348 byte arg2 ;
14349 byte arg3 ;
14350 byte arg4 ;
14351 bool result;
14352 void *argp1 = 0 ;
14353 int res1 = 0 ;
14354 unsigned char val2 ;
14355 int ecode2 = 0 ;
14356 unsigned char val3 ;
14357 int ecode3 = 0 ;
14358 unsigned char val4 ;
14359 int ecode4 = 0 ;
14360 PyObject * obj0 = 0 ;
14361 PyObject * obj1 = 0 ;
14362 PyObject * obj2 = 0 ;
14363 PyObject * obj3 = 0 ;
14364 char * kwnames[] = {
14365 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14366 };
14367
14368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14370 if (!SWIG_IsOK(res1)) {
14371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14372 }
14373 arg1 = reinterpret_cast< wxImage * >(argp1);
14374 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14375 if (!SWIG_IsOK(ecode2)) {
14376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14377 }
14378 arg2 = static_cast< byte >(val2);
14379 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14380 if (!SWIG_IsOK(ecode3)) {
14381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14382 }
14383 arg3 = static_cast< byte >(val3);
14384 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14385 if (!SWIG_IsOK(ecode4)) {
14386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14387 }
14388 arg4 = static_cast< byte >(val4);
14389 {
14390 PyThreadState* __tstate = wxPyBeginAllowThreads();
14391 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14392 wxPyEndAllowThreads(__tstate);
14393 if (PyErr_Occurred()) SWIG_fail;
14394 }
14395 {
14396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14397 }
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14405 PyObject *resultobj = 0;
14406 wxImage *arg1 = (wxImage *) 0 ;
14407 wxImage *arg2 = 0 ;
14408 byte arg3 ;
14409 byte arg4 ;
14410 byte arg5 ;
14411 bool result;
14412 void *argp1 = 0 ;
14413 int res1 = 0 ;
14414 void *argp2 = 0 ;
14415 int res2 = 0 ;
14416 unsigned char val3 ;
14417 int ecode3 = 0 ;
14418 unsigned char val4 ;
14419 int ecode4 = 0 ;
14420 unsigned char val5 ;
14421 int ecode5 = 0 ;
14422 PyObject * obj0 = 0 ;
14423 PyObject * obj1 = 0 ;
14424 PyObject * obj2 = 0 ;
14425 PyObject * obj3 = 0 ;
14426 PyObject * obj4 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14435 }
14436 arg1 = reinterpret_cast< wxImage * >(argp1);
14437 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14438 if (!SWIG_IsOK(res2)) {
14439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14440 }
14441 if (!argp2) {
14442 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14443 }
14444 arg2 = reinterpret_cast< wxImage * >(argp2);
14445 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14446 if (!SWIG_IsOK(ecode3)) {
14447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14448 }
14449 arg3 = static_cast< byte >(val3);
14450 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14451 if (!SWIG_IsOK(ecode4)) {
14452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14453 }
14454 arg4 = static_cast< byte >(val4);
14455 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14456 if (!SWIG_IsOK(ecode5)) {
14457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14458 }
14459 arg5 = static_cast< byte >(val5);
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 {
14467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14468 }
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxString *arg1 = 0 ;
14478 bool result;
14479 bool temp1 = false ;
14480 PyObject * obj0 = 0 ;
14481 char * kwnames[] = {
14482 (char *) "filename", NULL
14483 };
14484
14485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14486 {
14487 arg1 = wxString_in_helper(obj0);
14488 if (arg1 == NULL) SWIG_fail;
14489 temp1 = true;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 {
14498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14499 }
14500 {
14501 if (temp1)
14502 delete arg1;
14503 }
14504 return resultobj;
14505 fail:
14506 {
14507 if (temp1)
14508 delete arg1;
14509 }
14510 return NULL;
14511 }
14512
14513
14514 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14515 PyObject *resultobj = 0;
14516 wxString *arg1 = 0 ;
14517 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14518 int result;
14519 bool temp1 = false ;
14520 long val2 ;
14521 int ecode2 = 0 ;
14522 PyObject * obj0 = 0 ;
14523 PyObject * obj1 = 0 ;
14524 char * kwnames[] = {
14525 (char *) "filename",(char *) "type", NULL
14526 };
14527
14528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14529 {
14530 arg1 = wxString_in_helper(obj0);
14531 if (arg1 == NULL) SWIG_fail;
14532 temp1 = true;
14533 }
14534 if (obj1) {
14535 ecode2 = SWIG_AsVal_long(obj1, &val2);
14536 if (!SWIG_IsOK(ecode2)) {
14537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14538 }
14539 arg2 = static_cast< long >(val2);
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 resultobj = SWIG_From_int(static_cast< int >(result));
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp1)
14556 delete arg1;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxImage *arg1 = (wxImage *) 0 ;
14565 wxString *arg2 = 0 ;
14566 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14567 int arg4 = (int) -1 ;
14568 bool result;
14569 void *argp1 = 0 ;
14570 int res1 = 0 ;
14571 bool temp2 = false ;
14572 long val3 ;
14573 int ecode3 = 0 ;
14574 int val4 ;
14575 int ecode4 = 0 ;
14576 PyObject * obj0 = 0 ;
14577 PyObject * obj1 = 0 ;
14578 PyObject * obj2 = 0 ;
14579 PyObject * obj3 = 0 ;
14580 char * kwnames[] = {
14581 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14582 };
14583
14584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14588 }
14589 arg1 = reinterpret_cast< wxImage * >(argp1);
14590 {
14591 arg2 = wxString_in_helper(obj1);
14592 if (arg2 == NULL) SWIG_fail;
14593 temp2 = true;
14594 }
14595 if (obj2) {
14596 ecode3 = SWIG_AsVal_long(obj2, &val3);
14597 if (!SWIG_IsOK(ecode3)) {
14598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14599 }
14600 arg3 = static_cast< long >(val3);
14601 }
14602 if (obj3) {
14603 ecode4 = SWIG_AsVal_int(obj3, &val4);
14604 if (!SWIG_IsOK(ecode4)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14606 }
14607 arg4 = static_cast< int >(val4);
14608 }
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 return resultobj;
14623 fail:
14624 {
14625 if (temp2)
14626 delete arg2;
14627 }
14628 return NULL;
14629 }
14630
14631
14632 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14633 PyObject *resultobj = 0;
14634 wxImage *arg1 = (wxImage *) 0 ;
14635 wxString *arg2 = 0 ;
14636 wxString *arg3 = 0 ;
14637 int arg4 = (int) -1 ;
14638 bool result;
14639 void *argp1 = 0 ;
14640 int res1 = 0 ;
14641 bool temp2 = false ;
14642 bool temp3 = false ;
14643 int val4 ;
14644 int ecode4 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 PyObject * obj2 = 0 ;
14648 PyObject * obj3 = 0 ;
14649 char * kwnames[] = {
14650 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14651 };
14652
14653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14655 if (!SWIG_IsOK(res1)) {
14656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14657 }
14658 arg1 = reinterpret_cast< wxImage * >(argp1);
14659 {
14660 arg2 = wxString_in_helper(obj1);
14661 if (arg2 == NULL) SWIG_fail;
14662 temp2 = true;
14663 }
14664 {
14665 arg3 = wxString_in_helper(obj2);
14666 if (arg3 == NULL) SWIG_fail;
14667 temp3 = true;
14668 }
14669 if (obj3) {
14670 ecode4 = SWIG_AsVal_int(obj3, &val4);
14671 if (!SWIG_IsOK(ecode4)) {
14672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14673 }
14674 arg4 = static_cast< int >(val4);
14675 }
14676 {
14677 PyThreadState* __tstate = wxPyBeginAllowThreads();
14678 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14679 wxPyEndAllowThreads(__tstate);
14680 if (PyErr_Occurred()) SWIG_fail;
14681 }
14682 {
14683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14684 }
14685 {
14686 if (temp2)
14687 delete arg2;
14688 }
14689 {
14690 if (temp3)
14691 delete arg3;
14692 }
14693 return resultobj;
14694 fail:
14695 {
14696 if (temp2)
14697 delete arg2;
14698 }
14699 {
14700 if (temp3)
14701 delete arg3;
14702 }
14703 return NULL;
14704 }
14705
14706
14707 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14708 PyObject *resultobj = 0;
14709 wxImage *arg1 = (wxImage *) 0 ;
14710 wxString *arg2 = 0 ;
14711 int arg3 ;
14712 bool result;
14713 void *argp1 = 0 ;
14714 int res1 = 0 ;
14715 bool temp2 = false ;
14716 int val3 ;
14717 int ecode3 = 0 ;
14718 PyObject * obj0 = 0 ;
14719 PyObject * obj1 = 0 ;
14720 PyObject * obj2 = 0 ;
14721 char * kwnames[] = {
14722 (char *) "self",(char *) "name",(char *) "type", NULL
14723 };
14724
14725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14727 if (!SWIG_IsOK(res1)) {
14728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14729 }
14730 arg1 = reinterpret_cast< wxImage * >(argp1);
14731 {
14732 arg2 = wxString_in_helper(obj1);
14733 if (arg2 == NULL) SWIG_fail;
14734 temp2 = true;
14735 }
14736 ecode3 = SWIG_AsVal_int(obj2, &val3);
14737 if (!SWIG_IsOK(ecode3)) {
14738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14739 }
14740 arg3 = static_cast< int >(val3);
14741 {
14742 PyThreadState* __tstate = wxPyBeginAllowThreads();
14743 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 {
14748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14749 }
14750 {
14751 if (temp2)
14752 delete arg2;
14753 }
14754 return resultobj;
14755 fail:
14756 {
14757 if (temp2)
14758 delete arg2;
14759 }
14760 return NULL;
14761 }
14762
14763
14764 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj = 0;
14766 wxImage *arg1 = (wxImage *) 0 ;
14767 wxString *arg2 = 0 ;
14768 wxString *arg3 = 0 ;
14769 bool result;
14770 void *argp1 = 0 ;
14771 int res1 = 0 ;
14772 bool temp2 = false ;
14773 bool temp3 = false ;
14774 PyObject * obj0 = 0 ;
14775 PyObject * obj1 = 0 ;
14776 PyObject * obj2 = 0 ;
14777 char * kwnames[] = {
14778 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14779 };
14780
14781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14783 if (!SWIG_IsOK(res1)) {
14784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14785 }
14786 arg1 = reinterpret_cast< wxImage * >(argp1);
14787 {
14788 arg2 = wxString_in_helper(obj1);
14789 if (arg2 == NULL) SWIG_fail;
14790 temp2 = true;
14791 }
14792 {
14793 arg3 = wxString_in_helper(obj2);
14794 if (arg3 == NULL) SWIG_fail;
14795 temp3 = true;
14796 }
14797 {
14798 PyThreadState* __tstate = wxPyBeginAllowThreads();
14799 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14800 wxPyEndAllowThreads(__tstate);
14801 if (PyErr_Occurred()) SWIG_fail;
14802 }
14803 {
14804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14805 }
14806 {
14807 if (temp2)
14808 delete arg2;
14809 }
14810 {
14811 if (temp3)
14812 delete arg3;
14813 }
14814 return resultobj;
14815 fail:
14816 {
14817 if (temp2)
14818 delete arg2;
14819 }
14820 {
14821 if (temp3)
14822 delete arg3;
14823 }
14824 return NULL;
14825 }
14826
14827
14828 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj = 0;
14830 wxInputStream *arg1 = 0 ;
14831 bool result;
14832 wxPyInputStream *temp1 ;
14833 bool created1 ;
14834 PyObject * obj0 = 0 ;
14835 char * kwnames[] = {
14836 (char *) "stream", NULL
14837 };
14838
14839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14840 {
14841 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14842 arg1 = temp1->m_wxis;
14843 created1 = false;
14844 } else {
14845 PyErr_Clear(); // clear the failure of the wxPyConvert above
14846 arg1 = wxPyCBInputStream_create(obj0, false);
14847 if (arg1 == NULL) {
14848 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14849 SWIG_fail;
14850 }
14851 created1 = true;
14852 }
14853 }
14854 {
14855 PyThreadState* __tstate = wxPyBeginAllowThreads();
14856 result = (bool)wxImage::CanRead(*arg1);
14857 wxPyEndAllowThreads(__tstate);
14858 if (PyErr_Occurred()) SWIG_fail;
14859 }
14860 {
14861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14862 }
14863 {
14864 if (created1) delete arg1;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (created1) delete arg1;
14870 }
14871 return NULL;
14872 }
14873
14874
14875 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14876 PyObject *resultobj = 0;
14877 wxImage *arg1 = (wxImage *) 0 ;
14878 wxInputStream *arg2 = 0 ;
14879 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14880 int arg4 = (int) -1 ;
14881 bool result;
14882 void *argp1 = 0 ;
14883 int res1 = 0 ;
14884 wxPyInputStream *temp2 ;
14885 bool created2 ;
14886 long val3 ;
14887 int ecode3 = 0 ;
14888 int val4 ;
14889 int ecode4 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 PyObject * obj3 = 0 ;
14894 char * kwnames[] = {
14895 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14896 };
14897
14898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14900 if (!SWIG_IsOK(res1)) {
14901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14902 }
14903 arg1 = reinterpret_cast< wxImage * >(argp1);
14904 {
14905 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14906 arg2 = temp2->m_wxis;
14907 created2 = false;
14908 } else {
14909 PyErr_Clear(); // clear the failure of the wxPyConvert above
14910 arg2 = wxPyCBInputStream_create(obj1, false);
14911 if (arg2 == NULL) {
14912 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14913 SWIG_fail;
14914 }
14915 created2 = true;
14916 }
14917 }
14918 if (obj2) {
14919 ecode3 = SWIG_AsVal_long(obj2, &val3);
14920 if (!SWIG_IsOK(ecode3)) {
14921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14922 }
14923 arg3 = static_cast< long >(val3);
14924 }
14925 if (obj3) {
14926 ecode4 = SWIG_AsVal_int(obj3, &val4);
14927 if (!SWIG_IsOK(ecode4)) {
14928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14929 }
14930 arg4 = static_cast< int >(val4);
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14935 wxPyEndAllowThreads(__tstate);
14936 if (PyErr_Occurred()) SWIG_fail;
14937 }
14938 {
14939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14940 }
14941 {
14942 if (created2) delete arg2;
14943 }
14944 return resultobj;
14945 fail:
14946 {
14947 if (created2) delete arg2;
14948 }
14949 return NULL;
14950 }
14951
14952
14953 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14954 PyObject *resultobj = 0;
14955 wxImage *arg1 = (wxImage *) 0 ;
14956 wxInputStream *arg2 = 0 ;
14957 wxString *arg3 = 0 ;
14958 int arg4 = (int) -1 ;
14959 bool result;
14960 void *argp1 = 0 ;
14961 int res1 = 0 ;
14962 wxPyInputStream *temp2 ;
14963 bool created2 ;
14964 bool temp3 = false ;
14965 int val4 ;
14966 int ecode4 = 0 ;
14967 PyObject * obj0 = 0 ;
14968 PyObject * obj1 = 0 ;
14969 PyObject * obj2 = 0 ;
14970 PyObject * obj3 = 0 ;
14971 char * kwnames[] = {
14972 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14973 };
14974
14975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14977 if (!SWIG_IsOK(res1)) {
14978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14979 }
14980 arg1 = reinterpret_cast< wxImage * >(argp1);
14981 {
14982 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14983 arg2 = temp2->m_wxis;
14984 created2 = false;
14985 } else {
14986 PyErr_Clear(); // clear the failure of the wxPyConvert above
14987 arg2 = wxPyCBInputStream_create(obj1, false);
14988 if (arg2 == NULL) {
14989 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14990 SWIG_fail;
14991 }
14992 created2 = true;
14993 }
14994 }
14995 {
14996 arg3 = wxString_in_helper(obj2);
14997 if (arg3 == NULL) SWIG_fail;
14998 temp3 = true;
14999 }
15000 if (obj3) {
15001 ecode4 = SWIG_AsVal_int(obj3, &val4);
15002 if (!SWIG_IsOK(ecode4)) {
15003 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15004 }
15005 arg4 = static_cast< int >(val4);
15006 }
15007 {
15008 PyThreadState* __tstate = wxPyBeginAllowThreads();
15009 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15010 wxPyEndAllowThreads(__tstate);
15011 if (PyErr_Occurred()) SWIG_fail;
15012 }
15013 {
15014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15015 }
15016 {
15017 if (created2) delete arg2;
15018 }
15019 {
15020 if (temp3)
15021 delete arg3;
15022 }
15023 return resultobj;
15024 fail:
15025 {
15026 if (created2) delete arg2;
15027 }
15028 {
15029 if (temp3)
15030 delete arg3;
15031 }
15032 return NULL;
15033 }
15034
15035
15036 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15037 PyObject *resultobj = 0;
15038 wxImage *arg1 = (wxImage *) 0 ;
15039 bool result;
15040 void *argp1 = 0 ;
15041 int res1 = 0 ;
15042 PyObject *swig_obj[1] ;
15043
15044 if (!args) SWIG_fail;
15045 swig_obj[0] = args;
15046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15047 if (!SWIG_IsOK(res1)) {
15048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15049 }
15050 arg1 = reinterpret_cast< wxImage * >(argp1);
15051 {
15052 PyThreadState* __tstate = wxPyBeginAllowThreads();
15053 result = (bool)(arg1)->Ok();
15054 wxPyEndAllowThreads(__tstate);
15055 if (PyErr_Occurred()) SWIG_fail;
15056 }
15057 {
15058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15059 }
15060 return resultobj;
15061 fail:
15062 return NULL;
15063 }
15064
15065
15066 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15067 PyObject *resultobj = 0;
15068 wxImage *arg1 = (wxImage *) 0 ;
15069 int result;
15070 void *argp1 = 0 ;
15071 int res1 = 0 ;
15072 PyObject *swig_obj[1] ;
15073
15074 if (!args) SWIG_fail;
15075 swig_obj[0] = args;
15076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15077 if (!SWIG_IsOK(res1)) {
15078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15079 }
15080 arg1 = reinterpret_cast< wxImage * >(argp1);
15081 {
15082 PyThreadState* __tstate = wxPyBeginAllowThreads();
15083 result = (int)(arg1)->GetWidth();
15084 wxPyEndAllowThreads(__tstate);
15085 if (PyErr_Occurred()) SWIG_fail;
15086 }
15087 resultobj = SWIG_From_int(static_cast< int >(result));
15088 return resultobj;
15089 fail:
15090 return NULL;
15091 }
15092
15093
15094 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15095 PyObject *resultobj = 0;
15096 wxImage *arg1 = (wxImage *) 0 ;
15097 int result;
15098 void *argp1 = 0 ;
15099 int res1 = 0 ;
15100 PyObject *swig_obj[1] ;
15101
15102 if (!args) SWIG_fail;
15103 swig_obj[0] = args;
15104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15105 if (!SWIG_IsOK(res1)) {
15106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15107 }
15108 arg1 = reinterpret_cast< wxImage * >(argp1);
15109 {
15110 PyThreadState* __tstate = wxPyBeginAllowThreads();
15111 result = (int)(arg1)->GetHeight();
15112 wxPyEndAllowThreads(__tstate);
15113 if (PyErr_Occurred()) SWIG_fail;
15114 }
15115 resultobj = SWIG_From_int(static_cast< int >(result));
15116 return resultobj;
15117 fail:
15118 return NULL;
15119 }
15120
15121
15122 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15123 PyObject *resultobj = 0;
15124 wxImage *arg1 = (wxImage *) 0 ;
15125 wxSize result;
15126 void *argp1 = 0 ;
15127 int res1 = 0 ;
15128 PyObject *swig_obj[1] ;
15129
15130 if (!args) SWIG_fail;
15131 swig_obj[0] = args;
15132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage * >(argp1);
15137 {
15138 PyThreadState* __tstate = wxPyBeginAllowThreads();
15139 result = wxImage_GetSize(arg1);
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15144 return resultobj;
15145 fail:
15146 return NULL;
15147 }
15148
15149
15150 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj = 0;
15152 wxImage *arg1 = (wxImage *) 0 ;
15153 wxRect *arg2 = 0 ;
15154 SwigValueWrapper<wxImage > result;
15155 void *argp1 = 0 ;
15156 int res1 = 0 ;
15157 wxRect temp2 ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 char * kwnames[] = {
15161 (char *) "self",(char *) "rect", NULL
15162 };
15163
15164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15166 if (!SWIG_IsOK(res1)) {
15167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15168 }
15169 arg1 = reinterpret_cast< wxImage * >(argp1);
15170 {
15171 arg2 = &temp2;
15172 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15173 }
15174 {
15175 PyThreadState* __tstate = wxPyBeginAllowThreads();
15176 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15177 wxPyEndAllowThreads(__tstate);
15178 if (PyErr_Occurred()) SWIG_fail;
15179 }
15180 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15181 return resultobj;
15182 fail:
15183 return NULL;
15184 }
15185
15186
15187 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15188 PyObject *resultobj = 0;
15189 wxImage *arg1 = (wxImage *) 0 ;
15190 wxSize *arg2 = 0 ;
15191 wxPoint *arg3 = 0 ;
15192 int arg4 = (int) -1 ;
15193 int arg5 = (int) -1 ;
15194 int arg6 = (int) -1 ;
15195 SwigValueWrapper<wxImage > result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 wxSize temp2 ;
15199 wxPoint temp3 ;
15200 int val4 ;
15201 int ecode4 = 0 ;
15202 int val5 ;
15203 int ecode5 = 0 ;
15204 int val6 ;
15205 int ecode6 = 0 ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 PyObject * obj2 = 0 ;
15209 PyObject * obj3 = 0 ;
15210 PyObject * obj4 = 0 ;
15211 PyObject * obj5 = 0 ;
15212 char * kwnames[] = {
15213 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15214 };
15215
15216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15218 if (!SWIG_IsOK(res1)) {
15219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15220 }
15221 arg1 = reinterpret_cast< wxImage * >(argp1);
15222 {
15223 arg2 = &temp2;
15224 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15225 }
15226 {
15227 arg3 = &temp3;
15228 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15229 }
15230 if (obj3) {
15231 ecode4 = SWIG_AsVal_int(obj3, &val4);
15232 if (!SWIG_IsOK(ecode4)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15234 }
15235 arg4 = static_cast< int >(val4);
15236 }
15237 if (obj4) {
15238 ecode5 = SWIG_AsVal_int(obj4, &val5);
15239 if (!SWIG_IsOK(ecode5)) {
15240 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15241 }
15242 arg5 = static_cast< int >(val5);
15243 }
15244 if (obj5) {
15245 ecode6 = SWIG_AsVal_int(obj5, &val6);
15246 if (!SWIG_IsOK(ecode6)) {
15247 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15248 }
15249 arg6 = static_cast< int >(val6);
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15258 return resultobj;
15259 fail:
15260 return NULL;
15261 }
15262
15263
15264 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15265 PyObject *resultobj = 0;
15266 wxImage *arg1 = (wxImage *) 0 ;
15267 SwigValueWrapper<wxImage > result;
15268 void *argp1 = 0 ;
15269 int res1 = 0 ;
15270 PyObject *swig_obj[1] ;
15271
15272 if (!args) SWIG_fail;
15273 swig_obj[0] = args;
15274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15275 if (!SWIG_IsOK(res1)) {
15276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15277 }
15278 arg1 = reinterpret_cast< wxImage * >(argp1);
15279 {
15280 PyThreadState* __tstate = wxPyBeginAllowThreads();
15281 result = (arg1)->Copy();
15282 wxPyEndAllowThreads(__tstate);
15283 if (PyErr_Occurred()) SWIG_fail;
15284 }
15285 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15286 return resultobj;
15287 fail:
15288 return NULL;
15289 }
15290
15291
15292 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj = 0;
15294 wxImage *arg1 = (wxImage *) 0 ;
15295 wxImage *arg2 = 0 ;
15296 int arg3 ;
15297 int arg4 ;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 void *argp2 = 0 ;
15301 int res2 = 0 ;
15302 int val3 ;
15303 int ecode3 = 0 ;
15304 int val4 ;
15305 int ecode4 = 0 ;
15306 PyObject * obj0 = 0 ;
15307 PyObject * obj1 = 0 ;
15308 PyObject * obj2 = 0 ;
15309 PyObject * obj3 = 0 ;
15310 char * kwnames[] = {
15311 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15312 };
15313
15314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15316 if (!SWIG_IsOK(res1)) {
15317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15318 }
15319 arg1 = reinterpret_cast< wxImage * >(argp1);
15320 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15321 if (!SWIG_IsOK(res2)) {
15322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15323 }
15324 if (!argp2) {
15325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15326 }
15327 arg2 = reinterpret_cast< wxImage * >(argp2);
15328 ecode3 = SWIG_AsVal_int(obj2, &val3);
15329 if (!SWIG_IsOK(ecode3)) {
15330 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15331 }
15332 arg3 = static_cast< int >(val3);
15333 ecode4 = SWIG_AsVal_int(obj3, &val4);
15334 if (!SWIG_IsOK(ecode4)) {
15335 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15336 }
15337 arg4 = static_cast< int >(val4);
15338 {
15339 PyThreadState* __tstate = wxPyBeginAllowThreads();
15340 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 resultobj = SWIG_Py_Void();
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage *arg1 = (wxImage *) 0 ;
15354 PyObject *result = 0 ;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 PyObject *swig_obj[1] ;
15358
15359 if (!args) SWIG_fail;
15360 swig_obj[0] = args;
15361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15362 if (!SWIG_IsOK(res1)) {
15363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15364 }
15365 arg1 = reinterpret_cast< wxImage * >(argp1);
15366 {
15367 PyThreadState* __tstate = wxPyBeginAllowThreads();
15368 result = (PyObject *)wxImage_GetData(arg1);
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 resultobj = result;
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj = 0;
15381 wxImage *arg1 = (wxImage *) 0 ;
15382 buffer arg2 ;
15383 int arg3 ;
15384 void *argp1 = 0 ;
15385 int res1 = 0 ;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 char * kwnames[] = {
15389 (char *) "self",(char *) "data", NULL
15390 };
15391
15392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage * >(argp1);
15398 {
15399 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15400 }
15401 {
15402 PyThreadState* __tstate = wxPyBeginAllowThreads();
15403 wxImage_SetData(arg1,arg2,arg3);
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 resultobj = SWIG_Py_Void();
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15415 PyObject *resultobj = 0;
15416 wxImage *arg1 = (wxImage *) 0 ;
15417 PyObject *result = 0 ;
15418 void *argp1 = 0 ;
15419 int res1 = 0 ;
15420 PyObject *swig_obj[1] ;
15421
15422 if (!args) SWIG_fail;
15423 swig_obj[0] = args;
15424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15425 if (!SWIG_IsOK(res1)) {
15426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15427 }
15428 arg1 = reinterpret_cast< wxImage * >(argp1);
15429 {
15430 PyThreadState* __tstate = wxPyBeginAllowThreads();
15431 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = result;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = 0;
15444 wxImage *arg1 = (wxImage *) 0 ;
15445 buffer arg2 ;
15446 int arg3 ;
15447 void *argp1 = 0 ;
15448 int res1 = 0 ;
15449 PyObject * obj0 = 0 ;
15450 PyObject * obj1 = 0 ;
15451 char * kwnames[] = {
15452 (char *) "self",(char *) "data", NULL
15453 };
15454
15455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15457 if (!SWIG_IsOK(res1)) {
15458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15459 }
15460 arg1 = reinterpret_cast< wxImage * >(argp1);
15461 {
15462 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15463 }
15464 {
15465 PyThreadState* __tstate = wxPyBeginAllowThreads();
15466 wxImage_SetDataBuffer(arg1,arg2,arg3);
15467 wxPyEndAllowThreads(__tstate);
15468 if (PyErr_Occurred()) SWIG_fail;
15469 }
15470 resultobj = SWIG_Py_Void();
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage *arg1 = (wxImage *) 0 ;
15480 PyObject *result = 0 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 PyObject *swig_obj[1] ;
15484
15485 if (!args) SWIG_fail;
15486 swig_obj[0] = args;
15487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15488 if (!SWIG_IsOK(res1)) {
15489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15490 }
15491 arg1 = reinterpret_cast< wxImage * >(argp1);
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 result = (PyObject *)wxImage_GetAlphaData(arg1);
15495 wxPyEndAllowThreads(__tstate);
15496 if (PyErr_Occurred()) SWIG_fail;
15497 }
15498 resultobj = result;
15499 return resultobj;
15500 fail:
15501 return NULL;
15502 }
15503
15504
15505 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15506 PyObject *resultobj = 0;
15507 wxImage *arg1 = (wxImage *) 0 ;
15508 buffer arg2 ;
15509 int arg3 ;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 PyObject * obj0 = 0 ;
15513 PyObject * obj1 = 0 ;
15514 char * kwnames[] = {
15515 (char *) "self",(char *) "alpha", NULL
15516 };
15517
15518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15520 if (!SWIG_IsOK(res1)) {
15521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15522 }
15523 arg1 = reinterpret_cast< wxImage * >(argp1);
15524 {
15525 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15526 }
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 wxImage_SetAlphaData(arg1,arg2,arg3);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_Py_Void();
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15541 PyObject *resultobj = 0;
15542 wxImage *arg1 = (wxImage *) 0 ;
15543 PyObject *result = 0 ;
15544 void *argp1 = 0 ;
15545 int res1 = 0 ;
15546 PyObject *swig_obj[1] ;
15547
15548 if (!args) SWIG_fail;
15549 swig_obj[0] = args;
15550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15553 }
15554 arg1 = reinterpret_cast< wxImage * >(argp1);
15555 {
15556 PyThreadState* __tstate = wxPyBeginAllowThreads();
15557 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15558 wxPyEndAllowThreads(__tstate);
15559 if (PyErr_Occurred()) SWIG_fail;
15560 }
15561 resultobj = result;
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15569 PyObject *resultobj = 0;
15570 wxImage *arg1 = (wxImage *) 0 ;
15571 buffer arg2 ;
15572 int arg3 ;
15573 void *argp1 = 0 ;
15574 int res1 = 0 ;
15575 PyObject * obj0 = 0 ;
15576 PyObject * obj1 = 0 ;
15577 char * kwnames[] = {
15578 (char *) "self",(char *) "alpha", NULL
15579 };
15580
15581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15585 }
15586 arg1 = reinterpret_cast< wxImage * >(argp1);
15587 {
15588 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15593 wxPyEndAllowThreads(__tstate);
15594 if (PyErr_Occurred()) SWIG_fail;
15595 }
15596 resultobj = SWIG_Py_Void();
15597 return resultobj;
15598 fail:
15599 return NULL;
15600 }
15601
15602
15603 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15604 PyObject *resultobj = 0;
15605 wxImage *arg1 = (wxImage *) 0 ;
15606 byte arg2 ;
15607 byte arg3 ;
15608 byte arg4 ;
15609 void *argp1 = 0 ;
15610 int res1 = 0 ;
15611 unsigned char val2 ;
15612 int ecode2 = 0 ;
15613 unsigned char val3 ;
15614 int ecode3 = 0 ;
15615 unsigned char val4 ;
15616 int ecode4 = 0 ;
15617 PyObject * obj0 = 0 ;
15618 PyObject * obj1 = 0 ;
15619 PyObject * obj2 = 0 ;
15620 PyObject * obj3 = 0 ;
15621 char * kwnames[] = {
15622 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15623 };
15624
15625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15627 if (!SWIG_IsOK(res1)) {
15628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15629 }
15630 arg1 = reinterpret_cast< wxImage * >(argp1);
15631 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15632 if (!SWIG_IsOK(ecode2)) {
15633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15634 }
15635 arg2 = static_cast< byte >(val2);
15636 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15637 if (!SWIG_IsOK(ecode3)) {
15638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15639 }
15640 arg3 = static_cast< byte >(val3);
15641 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15642 if (!SWIG_IsOK(ecode4)) {
15643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15644 }
15645 arg4 = static_cast< byte >(val4);
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 (arg1)->SetMaskColour(arg2,arg3,arg4);
15649 wxPyEndAllowThreads(__tstate);
15650 if (PyErr_Occurred()) SWIG_fail;
15651 }
15652 resultobj = SWIG_Py_Void();
15653 return resultobj;
15654 fail:
15655 return NULL;
15656 }
15657
15658
15659 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15660 PyObject *resultobj = 0;
15661 wxImage *arg1 = (wxImage *) 0 ;
15662 byte *arg2 = (byte *) 0 ;
15663 byte *arg3 = (byte *) 0 ;
15664 byte *arg4 = (byte *) 0 ;
15665 void *argp1 = 0 ;
15666 int res1 = 0 ;
15667 byte temp2 ;
15668 int res2 = SWIG_TMPOBJ ;
15669 byte temp3 ;
15670 int res3 = SWIG_TMPOBJ ;
15671 byte temp4 ;
15672 int res4 = SWIG_TMPOBJ ;
15673 PyObject *swig_obj[1] ;
15674
15675 arg2 = &temp2;
15676 arg3 = &temp3;
15677 arg4 = &temp4;
15678 if (!args) SWIG_fail;
15679 swig_obj[0] = args;
15680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15681 if (!SWIG_IsOK(res1)) {
15682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15683 }
15684 arg1 = reinterpret_cast< wxImage * >(argp1);
15685 {
15686 PyThreadState* __tstate = wxPyBeginAllowThreads();
15687 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 resultobj = SWIG_Py_Void();
15692 if (SWIG_IsTmpObj(res2)) {
15693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15694 } else {
15695 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15697 }
15698 if (SWIG_IsTmpObj(res3)) {
15699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15700 } else {
15701 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15702 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15703 }
15704 if (SWIG_IsTmpObj(res4)) {
15705 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15706 } else {
15707 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15708 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15709 }
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15717 PyObject *resultobj = 0;
15718 wxImage *arg1 = (wxImage *) 0 ;
15719 byte result;
15720 void *argp1 = 0 ;
15721 int res1 = 0 ;
15722 PyObject *swig_obj[1] ;
15723
15724 if (!args) SWIG_fail;
15725 swig_obj[0] = args;
15726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15727 if (!SWIG_IsOK(res1)) {
15728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15729 }
15730 arg1 = reinterpret_cast< wxImage * >(argp1);
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 result = (byte)(arg1)->GetMaskRed();
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15745 PyObject *resultobj = 0;
15746 wxImage *arg1 = (wxImage *) 0 ;
15747 byte result;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 PyObject *swig_obj[1] ;
15751
15752 if (!args) SWIG_fail;
15753 swig_obj[0] = args;
15754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15755 if (!SWIG_IsOK(res1)) {
15756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15757 }
15758 arg1 = reinterpret_cast< wxImage * >(argp1);
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 result = (byte)(arg1)->GetMaskGreen();
15762 wxPyEndAllowThreads(__tstate);
15763 if (PyErr_Occurred()) SWIG_fail;
15764 }
15765 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15773 PyObject *resultobj = 0;
15774 wxImage *arg1 = (wxImage *) 0 ;
15775 byte result;
15776 void *argp1 = 0 ;
15777 int res1 = 0 ;
15778 PyObject *swig_obj[1] ;
15779
15780 if (!args) SWIG_fail;
15781 swig_obj[0] = args;
15782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15783 if (!SWIG_IsOK(res1)) {
15784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15785 }
15786 arg1 = reinterpret_cast< wxImage * >(argp1);
15787 {
15788 PyThreadState* __tstate = wxPyBeginAllowThreads();
15789 result = (byte)(arg1)->GetMaskBlue();
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = 0;
15802 wxImage *arg1 = (wxImage *) 0 ;
15803 bool arg2 = (bool) true ;
15804 void *argp1 = 0 ;
15805 int res1 = 0 ;
15806 bool val2 ;
15807 int ecode2 = 0 ;
15808 PyObject * obj0 = 0 ;
15809 PyObject * obj1 = 0 ;
15810 char * kwnames[] = {
15811 (char *) "self",(char *) "mask", NULL
15812 };
15813
15814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15816 if (!SWIG_IsOK(res1)) {
15817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15818 }
15819 arg1 = reinterpret_cast< wxImage * >(argp1);
15820 if (obj1) {
15821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15822 if (!SWIG_IsOK(ecode2)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15824 }
15825 arg2 = static_cast< bool >(val2);
15826 }
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 (arg1)->SetMask(arg2);
15830 wxPyEndAllowThreads(__tstate);
15831 if (PyErr_Occurred()) SWIG_fail;
15832 }
15833 resultobj = SWIG_Py_Void();
15834 return resultobj;
15835 fail:
15836 return NULL;
15837 }
15838
15839
15840 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15841 PyObject *resultobj = 0;
15842 wxImage *arg1 = (wxImage *) 0 ;
15843 bool result;
15844 void *argp1 = 0 ;
15845 int res1 = 0 ;
15846 PyObject *swig_obj[1] ;
15847
15848 if (!args) SWIG_fail;
15849 swig_obj[0] = args;
15850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15851 if (!SWIG_IsOK(res1)) {
15852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15853 }
15854 arg1 = reinterpret_cast< wxImage * >(argp1);
15855 {
15856 PyThreadState* __tstate = wxPyBeginAllowThreads();
15857 result = (bool)(arg1)->HasMask();
15858 wxPyEndAllowThreads(__tstate);
15859 if (PyErr_Occurred()) SWIG_fail;
15860 }
15861 {
15862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15863 }
15864 return resultobj;
15865 fail:
15866 return NULL;
15867 }
15868
15869
15870 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj = 0;
15872 wxImage *arg1 = (wxImage *) 0 ;
15873 double arg2 ;
15874 wxPoint *arg3 = 0 ;
15875 bool arg4 = (bool) true ;
15876 wxPoint *arg5 = (wxPoint *) NULL ;
15877 SwigValueWrapper<wxImage > result;
15878 void *argp1 = 0 ;
15879 int res1 = 0 ;
15880 double val2 ;
15881 int ecode2 = 0 ;
15882 wxPoint temp3 ;
15883 bool val4 ;
15884 int ecode4 = 0 ;
15885 void *argp5 = 0 ;
15886 int res5 = 0 ;
15887 PyObject * obj0 = 0 ;
15888 PyObject * obj1 = 0 ;
15889 PyObject * obj2 = 0 ;
15890 PyObject * obj3 = 0 ;
15891 PyObject * obj4 = 0 ;
15892 char * kwnames[] = {
15893 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15894 };
15895
15896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15900 }
15901 arg1 = reinterpret_cast< wxImage * >(argp1);
15902 ecode2 = SWIG_AsVal_double(obj1, &val2);
15903 if (!SWIG_IsOK(ecode2)) {
15904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15905 }
15906 arg2 = static_cast< double >(val2);
15907 {
15908 arg3 = &temp3;
15909 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15910 }
15911 if (obj3) {
15912 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15913 if (!SWIG_IsOK(ecode4)) {
15914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15915 }
15916 arg4 = static_cast< bool >(val4);
15917 }
15918 if (obj4) {
15919 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15920 if (!SWIG_IsOK(res5)) {
15921 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15922 }
15923 arg5 = reinterpret_cast< wxPoint * >(argp5);
15924 }
15925 {
15926 PyThreadState* __tstate = wxPyBeginAllowThreads();
15927 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15928 wxPyEndAllowThreads(__tstate);
15929 if (PyErr_Occurred()) SWIG_fail;
15930 }
15931 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15932 return resultobj;
15933 fail:
15934 return NULL;
15935 }
15936
15937
15938 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15939 PyObject *resultobj = 0;
15940 wxImage *arg1 = (wxImage *) 0 ;
15941 bool arg2 = (bool) true ;
15942 SwigValueWrapper<wxImage > result;
15943 void *argp1 = 0 ;
15944 int res1 = 0 ;
15945 bool val2 ;
15946 int ecode2 = 0 ;
15947 PyObject * obj0 = 0 ;
15948 PyObject * obj1 = 0 ;
15949 char * kwnames[] = {
15950 (char *) "self",(char *) "clockwise", NULL
15951 };
15952
15953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15955 if (!SWIG_IsOK(res1)) {
15956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15957 }
15958 arg1 = reinterpret_cast< wxImage * >(argp1);
15959 if (obj1) {
15960 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15961 if (!SWIG_IsOK(ecode2)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15963 }
15964 arg2 = static_cast< bool >(val2);
15965 }
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 result = (arg1)->Rotate90(arg2);
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15980 PyObject *resultobj = 0;
15981 wxImage *arg1 = (wxImage *) 0 ;
15982 bool arg2 = (bool) true ;
15983 SwigValueWrapper<wxImage > result;
15984 void *argp1 = 0 ;
15985 int res1 = 0 ;
15986 bool val2 ;
15987 int ecode2 = 0 ;
15988 PyObject * obj0 = 0 ;
15989 PyObject * obj1 = 0 ;
15990 char * kwnames[] = {
15991 (char *) "self",(char *) "horizontally", NULL
15992 };
15993
15994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15996 if (!SWIG_IsOK(res1)) {
15997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15998 }
15999 arg1 = reinterpret_cast< wxImage * >(argp1);
16000 if (obj1) {
16001 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16002 if (!SWIG_IsOK(ecode2)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16004 }
16005 arg2 = static_cast< bool >(val2);
16006 }
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (arg1)->Mirror(arg2);
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16021 PyObject *resultobj = 0;
16022 wxImage *arg1 = (wxImage *) 0 ;
16023 byte arg2 ;
16024 byte arg3 ;
16025 byte arg4 ;
16026 byte arg5 ;
16027 byte arg6 ;
16028 byte arg7 ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 unsigned char val2 ;
16032 int ecode2 = 0 ;
16033 unsigned char val3 ;
16034 int ecode3 = 0 ;
16035 unsigned char val4 ;
16036 int ecode4 = 0 ;
16037 unsigned char val5 ;
16038 int ecode5 = 0 ;
16039 unsigned char val6 ;
16040 int ecode6 = 0 ;
16041 unsigned char val7 ;
16042 int ecode7 = 0 ;
16043 PyObject * obj0 = 0 ;
16044 PyObject * obj1 = 0 ;
16045 PyObject * obj2 = 0 ;
16046 PyObject * obj3 = 0 ;
16047 PyObject * obj4 = 0 ;
16048 PyObject * obj5 = 0 ;
16049 PyObject * obj6 = 0 ;
16050 char * kwnames[] = {
16051 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16052 };
16053
16054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16056 if (!SWIG_IsOK(res1)) {
16057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16058 }
16059 arg1 = reinterpret_cast< wxImage * >(argp1);
16060 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16061 if (!SWIG_IsOK(ecode2)) {
16062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16063 }
16064 arg2 = static_cast< byte >(val2);
16065 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16066 if (!SWIG_IsOK(ecode3)) {
16067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16068 }
16069 arg3 = static_cast< byte >(val3);
16070 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16071 if (!SWIG_IsOK(ecode4)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16073 }
16074 arg4 = static_cast< byte >(val4);
16075 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16076 if (!SWIG_IsOK(ecode5)) {
16077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16078 }
16079 arg5 = static_cast< byte >(val5);
16080 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16081 if (!SWIG_IsOK(ecode6)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16083 }
16084 arg6 = static_cast< byte >(val6);
16085 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16086 if (!SWIG_IsOK(ecode7)) {
16087 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16088 }
16089 arg7 = static_cast< byte >(val7);
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = SWIG_Py_Void();
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 double arg2 = (double) 0.299 ;
16107 double arg3 = (double) 0.587 ;
16108 double arg4 = (double) 0.114 ;
16109 SwigValueWrapper<wxImage > result;
16110 void *argp1 = 0 ;
16111 int res1 = 0 ;
16112 double val2 ;
16113 int ecode2 = 0 ;
16114 double val3 ;
16115 int ecode3 = 0 ;
16116 double val4 ;
16117 int ecode4 = 0 ;
16118 PyObject * obj0 = 0 ;
16119 PyObject * obj1 = 0 ;
16120 PyObject * obj2 = 0 ;
16121 PyObject * obj3 = 0 ;
16122 char * kwnames[] = {
16123 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16124 };
16125
16126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16128 if (!SWIG_IsOK(res1)) {
16129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16130 }
16131 arg1 = reinterpret_cast< wxImage * >(argp1);
16132 if (obj1) {
16133 ecode2 = SWIG_AsVal_double(obj1, &val2);
16134 if (!SWIG_IsOK(ecode2)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16136 }
16137 arg2 = static_cast< double >(val2);
16138 }
16139 if (obj2) {
16140 ecode3 = SWIG_AsVal_double(obj2, &val3);
16141 if (!SWIG_IsOK(ecode3)) {
16142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16143 }
16144 arg3 = static_cast< double >(val3);
16145 }
16146 if (obj3) {
16147 ecode4 = SWIG_AsVal_double(obj3, &val4);
16148 if (!SWIG_IsOK(ecode4)) {
16149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16150 }
16151 arg4 = static_cast< double >(val4);
16152 }
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16156 wxPyEndAllowThreads(__tstate);
16157 if (PyErr_Occurred()) SWIG_fail;
16158 }
16159 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16160 return resultobj;
16161 fail:
16162 return NULL;
16163 }
16164
16165
16166 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16167 PyObject *resultobj = 0;
16168 wxImage *arg1 = (wxImage *) 0 ;
16169 byte arg2 ;
16170 byte arg3 ;
16171 byte arg4 ;
16172 SwigValueWrapper<wxImage > result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 unsigned char val2 ;
16176 int ecode2 = 0 ;
16177 unsigned char val3 ;
16178 int ecode3 = 0 ;
16179 unsigned char val4 ;
16180 int ecode4 = 0 ;
16181 PyObject * obj0 = 0 ;
16182 PyObject * obj1 = 0 ;
16183 PyObject * obj2 = 0 ;
16184 PyObject * obj3 = 0 ;
16185 char * kwnames[] = {
16186 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16187 };
16188
16189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16191 if (!SWIG_IsOK(res1)) {
16192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16193 }
16194 arg1 = reinterpret_cast< wxImage * >(argp1);
16195 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16196 if (!SWIG_IsOK(ecode2)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16198 }
16199 arg2 = static_cast< byte >(val2);
16200 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16201 if (!SWIG_IsOK(ecode3)) {
16202 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16203 }
16204 arg3 = static_cast< byte >(val3);
16205 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16206 if (!SWIG_IsOK(ecode4)) {
16207 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16208 }
16209 arg4 = static_cast< byte >(val4);
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16213 wxPyEndAllowThreads(__tstate);
16214 if (PyErr_Occurred()) SWIG_fail;
16215 }
16216 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16217 return resultobj;
16218 fail:
16219 return NULL;
16220 }
16221
16222
16223 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16224 PyObject *resultobj = 0;
16225 wxImage *arg1 = (wxImage *) 0 ;
16226 wxString *arg2 = 0 ;
16227 wxString *arg3 = 0 ;
16228 void *argp1 = 0 ;
16229 int res1 = 0 ;
16230 bool temp2 = false ;
16231 bool temp3 = false ;
16232 PyObject * obj0 = 0 ;
16233 PyObject * obj1 = 0 ;
16234 PyObject * obj2 = 0 ;
16235 char * kwnames[] = {
16236 (char *) "self",(char *) "name",(char *) "value", NULL
16237 };
16238
16239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16241 if (!SWIG_IsOK(res1)) {
16242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16243 }
16244 arg1 = reinterpret_cast< wxImage * >(argp1);
16245 {
16246 arg2 = wxString_in_helper(obj1);
16247 if (arg2 == NULL) SWIG_fail;
16248 temp2 = true;
16249 }
16250 {
16251 arg3 = wxString_in_helper(obj2);
16252 if (arg3 == NULL) SWIG_fail;
16253 temp3 = true;
16254 }
16255 {
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16258 wxPyEndAllowThreads(__tstate);
16259 if (PyErr_Occurred()) SWIG_fail;
16260 }
16261 resultobj = SWIG_Py_Void();
16262 {
16263 if (temp2)
16264 delete arg2;
16265 }
16266 {
16267 if (temp3)
16268 delete arg3;
16269 }
16270 return resultobj;
16271 fail:
16272 {
16273 if (temp2)
16274 delete arg2;
16275 }
16276 {
16277 if (temp3)
16278 delete arg3;
16279 }
16280 return NULL;
16281 }
16282
16283
16284 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16285 PyObject *resultobj = 0;
16286 wxImage *arg1 = (wxImage *) 0 ;
16287 wxString *arg2 = 0 ;
16288 int arg3 ;
16289 void *argp1 = 0 ;
16290 int res1 = 0 ;
16291 bool temp2 = false ;
16292 int val3 ;
16293 int ecode3 = 0 ;
16294 PyObject * obj0 = 0 ;
16295 PyObject * obj1 = 0 ;
16296 PyObject * obj2 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "name",(char *) "value", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 {
16308 arg2 = wxString_in_helper(obj1);
16309 if (arg2 == NULL) SWIG_fail;
16310 temp2 = true;
16311 }
16312 ecode3 = SWIG_AsVal_int(obj2, &val3);
16313 if (!SWIG_IsOK(ecode3)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16315 }
16316 arg3 = static_cast< int >(val3);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 (arg1)->SetOption((wxString const &)*arg2,arg3);
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 resultobj = SWIG_Py_Void();
16324 {
16325 if (temp2)
16326 delete arg2;
16327 }
16328 return resultobj;
16329 fail:
16330 {
16331 if (temp2)
16332 delete arg2;
16333 }
16334 return NULL;
16335 }
16336
16337
16338 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16339 PyObject *resultobj = 0;
16340 wxImage *arg1 = (wxImage *) 0 ;
16341 wxString *arg2 = 0 ;
16342 wxString result;
16343 void *argp1 = 0 ;
16344 int res1 = 0 ;
16345 bool temp2 = false ;
16346 PyObject * obj0 = 0 ;
16347 PyObject * obj1 = 0 ;
16348 char * kwnames[] = {
16349 (char *) "self",(char *) "name", NULL
16350 };
16351
16352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16354 if (!SWIG_IsOK(res1)) {
16355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16356 }
16357 arg1 = reinterpret_cast< wxImage * >(argp1);
16358 {
16359 arg2 = wxString_in_helper(obj1);
16360 if (arg2 == NULL) SWIG_fail;
16361 temp2 = true;
16362 }
16363 {
16364 PyThreadState* __tstate = wxPyBeginAllowThreads();
16365 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16366 wxPyEndAllowThreads(__tstate);
16367 if (PyErr_Occurred()) SWIG_fail;
16368 }
16369 {
16370 #if wxUSE_UNICODE
16371 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16372 #else
16373 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16374 #endif
16375 }
16376 {
16377 if (temp2)
16378 delete arg2;
16379 }
16380 return resultobj;
16381 fail:
16382 {
16383 if (temp2)
16384 delete arg2;
16385 }
16386 return NULL;
16387 }
16388
16389
16390 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16391 PyObject *resultobj = 0;
16392 wxImage *arg1 = (wxImage *) 0 ;
16393 wxString *arg2 = 0 ;
16394 int result;
16395 void *argp1 = 0 ;
16396 int res1 = 0 ;
16397 bool temp2 = false ;
16398 PyObject * obj0 = 0 ;
16399 PyObject * obj1 = 0 ;
16400 char * kwnames[] = {
16401 (char *) "self",(char *) "name", NULL
16402 };
16403
16404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16406 if (!SWIG_IsOK(res1)) {
16407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16408 }
16409 arg1 = reinterpret_cast< wxImage * >(argp1);
16410 {
16411 arg2 = wxString_in_helper(obj1);
16412 if (arg2 == NULL) SWIG_fail;
16413 temp2 = true;
16414 }
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 resultobj = SWIG_From_int(static_cast< int >(result));
16422 {
16423 if (temp2)
16424 delete arg2;
16425 }
16426 return resultobj;
16427 fail:
16428 {
16429 if (temp2)
16430 delete arg2;
16431 }
16432 return NULL;
16433 }
16434
16435
16436 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16437 PyObject *resultobj = 0;
16438 wxImage *arg1 = (wxImage *) 0 ;
16439 wxString *arg2 = 0 ;
16440 bool result;
16441 void *argp1 = 0 ;
16442 int res1 = 0 ;
16443 bool temp2 = false ;
16444 PyObject * obj0 = 0 ;
16445 PyObject * obj1 = 0 ;
16446 char * kwnames[] = {
16447 (char *) "self",(char *) "name", NULL
16448 };
16449
16450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16452 if (!SWIG_IsOK(res1)) {
16453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16454 }
16455 arg1 = reinterpret_cast< wxImage * >(argp1);
16456 {
16457 arg2 = wxString_in_helper(obj1);
16458 if (arg2 == NULL) SWIG_fail;
16459 temp2 = true;
16460 }
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 {
16468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16469 }
16470 {
16471 if (temp2)
16472 delete arg2;
16473 }
16474 return resultobj;
16475 fail:
16476 {
16477 if (temp2)
16478 delete arg2;
16479 }
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxImage *arg1 = (wxImage *) 0 ;
16487 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16488 unsigned long result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 unsigned long val2 ;
16492 int ecode2 = 0 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 char * kwnames[] = {
16496 (char *) "self",(char *) "stopafter", NULL
16497 };
16498
16499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16501 if (!SWIG_IsOK(res1)) {
16502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16503 }
16504 arg1 = reinterpret_cast< wxImage * >(argp1);
16505 if (obj1) {
16506 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16507 if (!SWIG_IsOK(ecode2)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16509 }
16510 arg2 = static_cast< unsigned long >(val2);
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (unsigned long)(arg1)->CountColours(arg2);
16515 wxPyEndAllowThreads(__tstate);
16516 if (PyErr_Occurred()) SWIG_fail;
16517 }
16518 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxImage *arg1 = (wxImage *) 0 ;
16528 wxImageHistogram *arg2 = 0 ;
16529 unsigned long result;
16530 void *argp1 = 0 ;
16531 int res1 = 0 ;
16532 void *argp2 = 0 ;
16533 int res2 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 char * kwnames[] = {
16537 (char *) "self",(char *) "h", NULL
16538 };
16539
16540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16542 if (!SWIG_IsOK(res1)) {
16543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16544 }
16545 arg1 = reinterpret_cast< wxImage * >(argp1);
16546 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16547 if (!SWIG_IsOK(res2)) {
16548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16549 }
16550 if (!argp2) {
16551 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16552 }
16553 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16557 wxPyEndAllowThreads(__tstate);
16558 if (PyErr_Occurred()) SWIG_fail;
16559 }
16560 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16561 return resultobj;
16562 fail:
16563 return NULL;
16564 }
16565
16566
16567 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16568 PyObject *resultobj = 0;
16569 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16570 void *argp1 = 0 ;
16571 int res1 = 0 ;
16572 PyObject * obj0 = 0 ;
16573 char * kwnames[] = {
16574 (char *) "handler", NULL
16575 };
16576
16577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16579 if (!SWIG_IsOK(res1)) {
16580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16581 }
16582 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 wxImage::AddHandler(arg1);
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 resultobj = SWIG_Py_Void();
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = 0;
16598 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16599 void *argp1 = 0 ;
16600 int res1 = 0 ;
16601 PyObject * obj0 = 0 ;
16602 char * kwnames[] = {
16603 (char *) "handler", NULL
16604 };
16605
16606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16608 if (!SWIG_IsOK(res1)) {
16609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16610 }
16611 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16612 {
16613 PyThreadState* __tstate = wxPyBeginAllowThreads();
16614 wxImage::InsertHandler(arg1);
16615 wxPyEndAllowThreads(__tstate);
16616 if (PyErr_Occurred()) SWIG_fail;
16617 }
16618 resultobj = SWIG_Py_Void();
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16626 PyObject *resultobj = 0;
16627 wxString *arg1 = 0 ;
16628 bool result;
16629 bool temp1 = false ;
16630 PyObject * obj0 = 0 ;
16631 char * kwnames[] = {
16632 (char *) "name", NULL
16633 };
16634
16635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16636 {
16637 arg1 = wxString_in_helper(obj0);
16638 if (arg1 == NULL) SWIG_fail;
16639 temp1 = true;
16640 }
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16644 wxPyEndAllowThreads(__tstate);
16645 if (PyErr_Occurred()) SWIG_fail;
16646 }
16647 {
16648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16649 }
16650 {
16651 if (temp1)
16652 delete arg1;
16653 }
16654 return resultobj;
16655 fail:
16656 {
16657 if (temp1)
16658 delete arg1;
16659 }
16660 return NULL;
16661 }
16662
16663
16664 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16665 PyObject *resultobj = 0;
16666 PyObject *result = 0 ;
16667
16668 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (PyObject *)wxImage_GetHandlers();
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 resultobj = result;
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16683 PyObject *resultobj = 0;
16684 wxString result;
16685
16686 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16687 {
16688 PyThreadState* __tstate = wxPyBeginAllowThreads();
16689 result = wxImage::GetImageExtWildcard();
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 {
16694 #if wxUSE_UNICODE
16695 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16696 #else
16697 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16698 #endif
16699 }
16700 return resultobj;
16701 fail:
16702 return NULL;
16703 }
16704
16705
16706 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16707 PyObject *resultobj = 0;
16708 wxImage *arg1 = (wxImage *) 0 ;
16709 int arg2 = (int) -1 ;
16710 wxBitmap result;
16711 void *argp1 = 0 ;
16712 int res1 = 0 ;
16713 int val2 ;
16714 int ecode2 = 0 ;
16715 PyObject * obj0 = 0 ;
16716 PyObject * obj1 = 0 ;
16717 char * kwnames[] = {
16718 (char *) "self",(char *) "depth", NULL
16719 };
16720
16721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16723 if (!SWIG_IsOK(res1)) {
16724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16725 }
16726 arg1 = reinterpret_cast< wxImage * >(argp1);
16727 if (obj1) {
16728 ecode2 = SWIG_AsVal_int(obj1, &val2);
16729 if (!SWIG_IsOK(ecode2)) {
16730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16731 }
16732 arg2 = static_cast< int >(val2);
16733 }
16734 {
16735 if (!wxPyCheckForApp()) SWIG_fail;
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = wxImage_ConvertToBitmap(arg1,arg2);
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16742 return resultobj;
16743 fail:
16744 return NULL;
16745 }
16746
16747
16748 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16749 PyObject *resultobj = 0;
16750 wxImage *arg1 = (wxImage *) 0 ;
16751 byte arg2 ;
16752 byte arg3 ;
16753 byte arg4 ;
16754 wxBitmap result;
16755 void *argp1 = 0 ;
16756 int res1 = 0 ;
16757 unsigned char val2 ;
16758 int ecode2 = 0 ;
16759 unsigned char val3 ;
16760 int ecode3 = 0 ;
16761 unsigned char val4 ;
16762 int ecode4 = 0 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 PyObject * obj2 = 0 ;
16766 PyObject * obj3 = 0 ;
16767 char * kwnames[] = {
16768 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16769 };
16770
16771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16773 if (!SWIG_IsOK(res1)) {
16774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16775 }
16776 arg1 = reinterpret_cast< wxImage * >(argp1);
16777 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16778 if (!SWIG_IsOK(ecode2)) {
16779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16780 }
16781 arg2 = static_cast< byte >(val2);
16782 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16783 if (!SWIG_IsOK(ecode3)) {
16784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16785 }
16786 arg3 = static_cast< byte >(val3);
16787 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16788 if (!SWIG_IsOK(ecode4)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16790 }
16791 arg4 = static_cast< byte >(val4);
16792 {
16793 if (!wxPyCheckForApp()) SWIG_fail;
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj = 0;
16808 wxImage *arg1 = (wxImage *) 0 ;
16809 double arg2 ;
16810 void *argp1 = 0 ;
16811 int res1 = 0 ;
16812 double val2 ;
16813 int ecode2 = 0 ;
16814 PyObject * obj0 = 0 ;
16815 PyObject * obj1 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "self",(char *) "angle", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16822 if (!SWIG_IsOK(res1)) {
16823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16824 }
16825 arg1 = reinterpret_cast< wxImage * >(argp1);
16826 ecode2 = SWIG_AsVal_double(obj1, &val2);
16827 if (!SWIG_IsOK(ecode2)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16829 }
16830 arg2 = static_cast< double >(val2);
16831 {
16832 PyThreadState* __tstate = wxPyBeginAllowThreads();
16833 (arg1)->RotateHue(arg2);
16834 wxPyEndAllowThreads(__tstate);
16835 if (PyErr_Occurred()) SWIG_fail;
16836 }
16837 resultobj = SWIG_Py_Void();
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16845 PyObject *resultobj = 0;
16846 wxImage_RGBValue arg1 ;
16847 wxImage_HSVValue result;
16848 void *argp1 ;
16849 int res1 = 0 ;
16850 PyObject * obj0 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "rgb", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16856 {
16857 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16858 if (!SWIG_IsOK(res1)) {
16859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16860 }
16861 if (!argp1) {
16862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16863 } else {
16864 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16865 arg1 = *temp;
16866 if (SWIG_IsNewObj(res1)) delete temp;
16867 }
16868 }
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = wxImage::RGBtoHSV(arg1);
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj = 0;
16884 wxImage_HSVValue arg1 ;
16885 wxImage_RGBValue result;
16886 void *argp1 ;
16887 int res1 = 0 ;
16888 PyObject * obj0 = 0 ;
16889 char * kwnames[] = {
16890 (char *) "hsv", NULL
16891 };
16892
16893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16894 {
16895 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16898 }
16899 if (!argp1) {
16900 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16901 } else {
16902 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16903 arg1 = *temp;
16904 if (SWIG_IsNewObj(res1)) delete temp;
16905 }
16906 }
16907 {
16908 PyThreadState* __tstate = wxPyBeginAllowThreads();
16909 result = wxImage::HSVtoRGB(arg1);
16910 wxPyEndAllowThreads(__tstate);
16911 if (PyErr_Occurred()) SWIG_fail;
16912 }
16913 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16914 return resultobj;
16915 fail:
16916 return NULL;
16917 }
16918
16919
16920 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16921 PyObject *obj;
16922 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16923 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16924 return SWIG_Py_Void();
16925 }
16926
16927 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16928 return SWIG_Python_InitShadowInstance(args);
16929 }
16930
16931 SWIGINTERN int NullImage_set(PyObject *) {
16932 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16933 return 1;
16934 }
16935
16936
16937 SWIGINTERN PyObject *NullImage_get(void) {
16938 PyObject *pyobj = 0;
16939
16940 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16941 return pyobj;
16942 }
16943
16944
16945 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16946 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16947 return 1;
16948 }
16949
16950
16951 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16952 PyObject *pyobj = 0;
16953
16954 {
16955 #if wxUSE_UNICODE
16956 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16957 #else
16958 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16959 #endif
16960 }
16961 return pyobj;
16962 }
16963
16964
16965 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16966 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16967 return 1;
16968 }
16969
16970
16971 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16972 PyObject *pyobj = 0;
16973
16974 {
16975 #if wxUSE_UNICODE
16976 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16977 #else
16978 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16979 #endif
16980 }
16981 return pyobj;
16982 }
16983
16984
16985 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16986 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16987 return 1;
16988 }
16989
16990
16991 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16992 PyObject *pyobj = 0;
16993
16994 {
16995 #if wxUSE_UNICODE
16996 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16997 #else
16998 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16999 #endif
17000 }
17001 return pyobj;
17002 }
17003
17004
17005 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17006 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17007 return 1;
17008 }
17009
17010
17011 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17012 PyObject *pyobj = 0;
17013
17014 {
17015 #if wxUSE_UNICODE
17016 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17017 #else
17018 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17019 #endif
17020 }
17021 return pyobj;
17022 }
17023
17024
17025 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17026 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17027 return 1;
17028 }
17029
17030
17031 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17032 PyObject *pyobj = 0;
17033
17034 {
17035 #if wxUSE_UNICODE
17036 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17037 #else
17038 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17039 #endif
17040 }
17041 return pyobj;
17042 }
17043
17044
17045 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17046 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17047 return 1;
17048 }
17049
17050
17051 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17052 PyObject *pyobj = 0;
17053
17054 {
17055 #if wxUSE_UNICODE
17056 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17057 #else
17058 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17059 #endif
17060 }
17061 return pyobj;
17062 }
17063
17064
17065 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17066 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17067 return 1;
17068 }
17069
17070
17071 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17072 PyObject *pyobj = 0;
17073
17074 {
17075 #if wxUSE_UNICODE
17076 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17077 #else
17078 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17079 #endif
17080 }
17081 return pyobj;
17082 }
17083
17084
17085 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17086 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17087 return 1;
17088 }
17089
17090
17091 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17092 PyObject *pyobj = 0;
17093
17094 {
17095 #if wxUSE_UNICODE
17096 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17097 #else
17098 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17099 #endif
17100 }
17101 return pyobj;
17102 }
17103
17104
17105 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17106 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17107 return 1;
17108 }
17109
17110
17111 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17112 PyObject *pyobj = 0;
17113
17114 {
17115 #if wxUSE_UNICODE
17116 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17117 #else
17118 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17119 #endif
17120 }
17121 return pyobj;
17122 }
17123
17124
17125 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17126 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17127 return 1;
17128 }
17129
17130
17131 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17132 PyObject *pyobj = 0;
17133
17134 {
17135 #if wxUSE_UNICODE
17136 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17137 #else
17138 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17139 #endif
17140 }
17141 return pyobj;
17142 }
17143
17144
17145 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17146 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17147 return 1;
17148 }
17149
17150
17151 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17152 PyObject *pyobj = 0;
17153
17154 {
17155 #if wxUSE_UNICODE
17156 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17157 #else
17158 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17159 #endif
17160 }
17161 return pyobj;
17162 }
17163
17164
17165 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17166 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17167 return 1;
17168 }
17169
17170
17171 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17172 PyObject *pyobj = 0;
17173
17174 {
17175 #if wxUSE_UNICODE
17176 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17177 #else
17178 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17179 #endif
17180 }
17181 return pyobj;
17182 }
17183
17184
17185 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17186 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17187 return 1;
17188 }
17189
17190
17191 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17192 PyObject *pyobj = 0;
17193
17194 {
17195 #if wxUSE_UNICODE
17196 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17197 #else
17198 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17199 #endif
17200 }
17201 return pyobj;
17202 }
17203
17204
17205 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17206 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17207 return 1;
17208 }
17209
17210
17211 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17212 PyObject *pyobj = 0;
17213
17214 {
17215 #if wxUSE_UNICODE
17216 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17217 #else
17218 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17219 #endif
17220 }
17221 return pyobj;
17222 }
17223
17224
17225 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17226 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17227 return 1;
17228 }
17229
17230
17231 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17232 PyObject *pyobj = 0;
17233
17234 {
17235 #if wxUSE_UNICODE
17236 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17237 #else
17238 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17239 #endif
17240 }
17241 return pyobj;
17242 }
17243
17244
17245 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17246 PyObject *resultobj = 0;
17247 wxBMPHandler *result = 0 ;
17248
17249 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (wxBMPHandler *)new wxBMPHandler();
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 PyObject *obj;
17265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17266 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17267 return SWIG_Py_Void();
17268 }
17269
17270 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 return SWIG_Python_InitShadowInstance(args);
17272 }
17273
17274 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17275 PyObject *resultobj = 0;
17276 wxICOHandler *result = 0 ;
17277
17278 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (wxICOHandler *)new wxICOHandler();
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 PyObject *obj;
17294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17295 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17296 return SWIG_Py_Void();
17297 }
17298
17299 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 return SWIG_Python_InitShadowInstance(args);
17301 }
17302
17303 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 PyObject *resultobj = 0;
17305 wxCURHandler *result = 0 ;
17306
17307 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17308 {
17309 PyThreadState* __tstate = wxPyBeginAllowThreads();
17310 result = (wxCURHandler *)new wxCURHandler();
17311 wxPyEndAllowThreads(__tstate);
17312 if (PyErr_Occurred()) SWIG_fail;
17313 }
17314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *obj;
17323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17324 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17325 return SWIG_Py_Void();
17326 }
17327
17328 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 return SWIG_Python_InitShadowInstance(args);
17330 }
17331
17332 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 wxANIHandler *result = 0 ;
17335
17336 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (wxANIHandler *)new wxANIHandler();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *obj;
17352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17353 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17354 return SWIG_Py_Void();
17355 }
17356
17357 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 return SWIG_Python_InitShadowInstance(args);
17359 }
17360
17361 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 PyObject *resultobj = 0;
17363 wxPNGHandler *result = 0 ;
17364
17365 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (wxPNGHandler *)new wxPNGHandler();
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 PyObject *obj;
17381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17382 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17383 return SWIG_Py_Void();
17384 }
17385
17386 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 return SWIG_Python_InitShadowInstance(args);
17388 }
17389
17390 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17391 PyObject *resultobj = 0;
17392 wxGIFHandler *result = 0 ;
17393
17394 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (wxGIFHandler *)new wxGIFHandler();
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17402 return resultobj;
17403 fail:
17404 return NULL;
17405 }
17406
17407
17408 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17409 PyObject *obj;
17410 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17411 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17412 return SWIG_Py_Void();
17413 }
17414
17415 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17416 return SWIG_Python_InitShadowInstance(args);
17417 }
17418
17419 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17420 PyObject *resultobj = 0;
17421 wxPCXHandler *result = 0 ;
17422
17423 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17424 {
17425 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (wxPCXHandler *)new wxPCXHandler();
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17431 return resultobj;
17432 fail:
17433 return NULL;
17434 }
17435
17436
17437 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17438 PyObject *obj;
17439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17440 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17441 return SWIG_Py_Void();
17442 }
17443
17444 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17445 return SWIG_Python_InitShadowInstance(args);
17446 }
17447
17448 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17449 PyObject *resultobj = 0;
17450 wxJPEGHandler *result = 0 ;
17451
17452 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17453 {
17454 PyThreadState* __tstate = wxPyBeginAllowThreads();
17455 result = (wxJPEGHandler *)new wxJPEGHandler();
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17460 return resultobj;
17461 fail:
17462 return NULL;
17463 }
17464
17465
17466 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *obj;
17468 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17469 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17470 return SWIG_Py_Void();
17471 }
17472
17473 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 return SWIG_Python_InitShadowInstance(args);
17475 }
17476
17477 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17478 PyObject *resultobj = 0;
17479 wxPNMHandler *result = 0 ;
17480
17481 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (wxPNMHandler *)new wxPNMHandler();
17485 wxPyEndAllowThreads(__tstate);
17486 if (PyErr_Occurred()) SWIG_fail;
17487 }
17488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17496 PyObject *obj;
17497 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17498 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17499 return SWIG_Py_Void();
17500 }
17501
17502 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17503 return SWIG_Python_InitShadowInstance(args);
17504 }
17505
17506 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17507 PyObject *resultobj = 0;
17508 wxXPMHandler *result = 0 ;
17509
17510 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17511 {
17512 PyThreadState* __tstate = wxPyBeginAllowThreads();
17513 result = (wxXPMHandler *)new wxXPMHandler();
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17525 PyObject *obj;
17526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17527 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17528 return SWIG_Py_Void();
17529 }
17530
17531 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17532 return SWIG_Python_InitShadowInstance(args);
17533 }
17534
17535 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17536 PyObject *resultobj = 0;
17537 wxTIFFHandler *result = 0 ;
17538
17539 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (wxTIFFHandler *)new wxTIFFHandler();
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17554 PyObject *obj;
17555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17556 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17557 return SWIG_Py_Void();
17558 }
17559
17560 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 return SWIG_Python_InitShadowInstance(args);
17562 }
17563
17564 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = 0;
17566 wxImage *arg1 = 0 ;
17567 wxImage *arg2 = 0 ;
17568 int arg3 = (int) 236 ;
17569 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17570 bool result;
17571 void *argp1 = 0 ;
17572 int res1 = 0 ;
17573 void *argp2 = 0 ;
17574 int res2 = 0 ;
17575 int val3 ;
17576 int ecode3 = 0 ;
17577 int val4 ;
17578 int ecode4 = 0 ;
17579 PyObject * obj0 = 0 ;
17580 PyObject * obj1 = 0 ;
17581 PyObject * obj2 = 0 ;
17582 PyObject * obj3 = 0 ;
17583 char * kwnames[] = {
17584 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17585 };
17586
17587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17588 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17589 if (!SWIG_IsOK(res1)) {
17590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17591 }
17592 if (!argp1) {
17593 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17594 }
17595 arg1 = reinterpret_cast< wxImage * >(argp1);
17596 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17597 if (!SWIG_IsOK(res2)) {
17598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17599 }
17600 if (!argp2) {
17601 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17602 }
17603 arg2 = reinterpret_cast< wxImage * >(argp2);
17604 if (obj2) {
17605 ecode3 = SWIG_AsVal_int(obj2, &val3);
17606 if (!SWIG_IsOK(ecode3)) {
17607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17608 }
17609 arg3 = static_cast< int >(val3);
17610 }
17611 if (obj3) {
17612 ecode4 = SWIG_AsVal_int(obj3, &val4);
17613 if (!SWIG_IsOK(ecode4)) {
17614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17615 }
17616 arg4 = static_cast< int >(val4);
17617 }
17618 {
17619 PyThreadState* __tstate = wxPyBeginAllowThreads();
17620 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17621 wxPyEndAllowThreads(__tstate);
17622 if (PyErr_Occurred()) SWIG_fail;
17623 }
17624 {
17625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17626 }
17627 return resultobj;
17628 fail:
17629 return NULL;
17630 }
17631
17632
17633 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17634 PyObject *obj;
17635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17636 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17637 return SWIG_Py_Void();
17638 }
17639
17640 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17641 PyObject *resultobj = 0;
17642 wxEvtHandler *result = 0 ;
17643
17644 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17645 {
17646 PyThreadState* __tstate = wxPyBeginAllowThreads();
17647 result = (wxEvtHandler *)new wxEvtHandler();
17648 wxPyEndAllowThreads(__tstate);
17649 if (PyErr_Occurred()) SWIG_fail;
17650 }
17651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17652 return resultobj;
17653 fail:
17654 return NULL;
17655 }
17656
17657
17658 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17659 PyObject *resultobj = 0;
17660 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17661 wxEvtHandler *result = 0 ;
17662 void *argp1 = 0 ;
17663 int res1 = 0 ;
17664 PyObject *swig_obj[1] ;
17665
17666 if (!args) SWIG_fail;
17667 swig_obj[0] = args;
17668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17669 if (!SWIG_IsOK(res1)) {
17670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17671 }
17672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17673 {
17674 PyThreadState* __tstate = wxPyBeginAllowThreads();
17675 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17676 wxPyEndAllowThreads(__tstate);
17677 if (PyErr_Occurred()) SWIG_fail;
17678 }
17679 {
17680 resultobj = wxPyMake_wxObject(result, 0);
17681 }
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17691 wxEvtHandler *result = 0 ;
17692 void *argp1 = 0 ;
17693 int res1 = 0 ;
17694 PyObject *swig_obj[1] ;
17695
17696 if (!args) SWIG_fail;
17697 swig_obj[0] = args;
17698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17699 if (!SWIG_IsOK(res1)) {
17700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17701 }
17702 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17703 {
17704 PyThreadState* __tstate = wxPyBeginAllowThreads();
17705 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = wxPyMake_wxObject(result, 0);
17711 }
17712 return resultobj;
17713 fail:
17714 return NULL;
17715 }
17716
17717
17718 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17719 PyObject *resultobj = 0;
17720 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17721 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17722 void *argp1 = 0 ;
17723 int res1 = 0 ;
17724 void *argp2 = 0 ;
17725 int res2 = 0 ;
17726 PyObject * obj0 = 0 ;
17727 PyObject * obj1 = 0 ;
17728 char * kwnames[] = {
17729 (char *) "self",(char *) "handler", NULL
17730 };
17731
17732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17734 if (!SWIG_IsOK(res1)) {
17735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17736 }
17737 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17739 if (!SWIG_IsOK(res2)) {
17740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17741 }
17742 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 (arg1)->SetNextHandler(arg2);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 resultobj = SWIG_Py_Void();
17750 return resultobj;
17751 fail:
17752 return NULL;
17753 }
17754
17755
17756 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj = 0;
17758 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17759 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17760 void *argp1 = 0 ;
17761 int res1 = 0 ;
17762 void *argp2 = 0 ;
17763 int res2 = 0 ;
17764 PyObject * obj0 = 0 ;
17765 PyObject * obj1 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "handler", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17774 }
17775 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17777 if (!SWIG_IsOK(res2)) {
17778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17779 }
17780 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17781 {
17782 PyThreadState* __tstate = wxPyBeginAllowThreads();
17783 (arg1)->SetPreviousHandler(arg2);
17784 wxPyEndAllowThreads(__tstate);
17785 if (PyErr_Occurred()) SWIG_fail;
17786 }
17787 resultobj = SWIG_Py_Void();
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17795 PyObject *resultobj = 0;
17796 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17797 bool result;
17798 void *argp1 = 0 ;
17799 int res1 = 0 ;
17800 PyObject *swig_obj[1] ;
17801
17802 if (!args) SWIG_fail;
17803 swig_obj[0] = args;
17804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17805 if (!SWIG_IsOK(res1)) {
17806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17807 }
17808 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17809 {
17810 PyThreadState* __tstate = wxPyBeginAllowThreads();
17811 result = (bool)(arg1)->GetEvtHandlerEnabled();
17812 wxPyEndAllowThreads(__tstate);
17813 if (PyErr_Occurred()) SWIG_fail;
17814 }
17815 {
17816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17817 }
17818 return resultobj;
17819 fail:
17820 return NULL;
17821 }
17822
17823
17824 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17825 PyObject *resultobj = 0;
17826 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17827 bool arg2 ;
17828 void *argp1 = 0 ;
17829 int res1 = 0 ;
17830 bool val2 ;
17831 int ecode2 = 0 ;
17832 PyObject * obj0 = 0 ;
17833 PyObject * obj1 = 0 ;
17834 char * kwnames[] = {
17835 (char *) "self",(char *) "enabled", NULL
17836 };
17837
17838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17842 }
17843 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17844 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17845 if (!SWIG_IsOK(ecode2)) {
17846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17847 }
17848 arg2 = static_cast< bool >(val2);
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 (arg1)->SetEvtHandlerEnabled(arg2);
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 resultobj = SWIG_Py_Void();
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj = 0;
17864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17865 wxEvent *arg2 = 0 ;
17866 bool result;
17867 void *argp1 = 0 ;
17868 int res1 = 0 ;
17869 void *argp2 = 0 ;
17870 int res2 = 0 ;
17871 PyObject * obj0 = 0 ;
17872 PyObject * obj1 = 0 ;
17873 char * kwnames[] = {
17874 (char *) "self",(char *) "event", NULL
17875 };
17876
17877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17879 if (!SWIG_IsOK(res1)) {
17880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17881 }
17882 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17884 if (!SWIG_IsOK(res2)) {
17885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17886 }
17887 if (!argp2) {
17888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17889 }
17890 arg2 = reinterpret_cast< wxEvent * >(argp2);
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (bool)(arg1)->ProcessEvent(*arg2);
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 {
17898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17899 }
17900 return resultobj;
17901 fail:
17902 return NULL;
17903 }
17904
17905
17906 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17907 PyObject *resultobj = 0;
17908 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17909 wxEvent *arg2 = 0 ;
17910 void *argp1 = 0 ;
17911 int res1 = 0 ;
17912 void *argp2 = 0 ;
17913 int res2 = 0 ;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 char * kwnames[] = {
17917 (char *) "self",(char *) "event", NULL
17918 };
17919
17920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17922 if (!SWIG_IsOK(res1)) {
17923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17924 }
17925 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17927 if (!SWIG_IsOK(res2)) {
17928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17929 }
17930 if (!argp2) {
17931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17932 }
17933 arg2 = reinterpret_cast< wxEvent * >(argp2);
17934 {
17935 PyThreadState* __tstate = wxPyBeginAllowThreads();
17936 (arg1)->AddPendingEvent(*arg2);
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 resultobj = SWIG_Py_Void();
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 PyObject *swig_obj[1] ;
17953
17954 if (!args) SWIG_fail;
17955 swig_obj[0] = args;
17956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17957 if (!SWIG_IsOK(res1)) {
17958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17959 }
17960 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 (arg1)->ProcessPendingEvents();
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 resultobj = SWIG_Py_Void();
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = 0;
17976 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17977 int arg2 ;
17978 int arg3 ;
17979 int arg4 ;
17980 PyObject *arg5 = (PyObject *) 0 ;
17981 void *argp1 = 0 ;
17982 int res1 = 0 ;
17983 int val2 ;
17984 int ecode2 = 0 ;
17985 int val3 ;
17986 int ecode3 = 0 ;
17987 int val4 ;
17988 int ecode4 = 0 ;
17989 PyObject * obj0 = 0 ;
17990 PyObject * obj1 = 0 ;
17991 PyObject * obj2 = 0 ;
17992 PyObject * obj3 = 0 ;
17993 PyObject * obj4 = 0 ;
17994 char * kwnames[] = {
17995 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17996 };
17997
17998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18000 if (!SWIG_IsOK(res1)) {
18001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18002 }
18003 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18004 ecode2 = SWIG_AsVal_int(obj1, &val2);
18005 if (!SWIG_IsOK(ecode2)) {
18006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18007 }
18008 arg2 = static_cast< int >(val2);
18009 ecode3 = SWIG_AsVal_int(obj2, &val3);
18010 if (!SWIG_IsOK(ecode3)) {
18011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18012 }
18013 arg3 = static_cast< int >(val3);
18014 ecode4 = SWIG_AsVal_int(obj3, &val4);
18015 if (!SWIG_IsOK(ecode4)) {
18016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18017 }
18018 arg4 = static_cast< int >(val4);
18019 arg5 = obj4;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18023 wxPyEndAllowThreads(__tstate);
18024 if (PyErr_Occurred()) SWIG_fail;
18025 }
18026 resultobj = SWIG_Py_Void();
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj = 0;
18035 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18036 int arg2 ;
18037 int arg3 = (int) -1 ;
18038 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18039 bool result;
18040 void *argp1 = 0 ;
18041 int res1 = 0 ;
18042 int val2 ;
18043 int ecode2 = 0 ;
18044 int val3 ;
18045 int ecode3 = 0 ;
18046 int val4 ;
18047 int ecode4 = 0 ;
18048 PyObject * obj0 = 0 ;
18049 PyObject * obj1 = 0 ;
18050 PyObject * obj2 = 0 ;
18051 PyObject * obj3 = 0 ;
18052 char * kwnames[] = {
18053 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18054 };
18055
18056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18060 }
18061 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18062 ecode2 = SWIG_AsVal_int(obj1, &val2);
18063 if (!SWIG_IsOK(ecode2)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18065 }
18066 arg2 = static_cast< int >(val2);
18067 if (obj2) {
18068 ecode3 = SWIG_AsVal_int(obj2, &val3);
18069 if (!SWIG_IsOK(ecode3)) {
18070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18071 }
18072 arg3 = static_cast< int >(val3);
18073 }
18074 if (obj3) {
18075 ecode4 = SWIG_AsVal_int(obj3, &val4);
18076 if (!SWIG_IsOK(ecode4)) {
18077 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18078 }
18079 arg4 = static_cast< wxEventType >(val4);
18080 }
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18084 wxPyEndAllowThreads(__tstate);
18085 if (PyErr_Occurred()) SWIG_fail;
18086 }
18087 {
18088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18089 }
18090 return resultobj;
18091 fail:
18092 return NULL;
18093 }
18094
18095
18096 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18097 PyObject *resultobj = 0;
18098 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18099 PyObject *arg2 = (PyObject *) 0 ;
18100 bool arg3 = (bool) true ;
18101 void *argp1 = 0 ;
18102 int res1 = 0 ;
18103 bool val3 ;
18104 int ecode3 = 0 ;
18105 PyObject * obj0 = 0 ;
18106 PyObject * obj1 = 0 ;
18107 PyObject * obj2 = 0 ;
18108 char * kwnames[] = {
18109 (char *) "self",(char *) "_self",(char *) "incref", NULL
18110 };
18111
18112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18118 arg2 = obj1;
18119 if (obj2) {
18120 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18121 if (!SWIG_IsOK(ecode3)) {
18122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18123 }
18124 arg3 = static_cast< bool >(val3);
18125 }
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18129 wxPyEndAllowThreads(__tstate);
18130 if (PyErr_Occurred()) SWIG_fail;
18131 }
18132 resultobj = SWIG_Py_Void();
18133 return resultobj;
18134 fail:
18135 return NULL;
18136 }
18137
18138
18139 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18140 PyObject *obj;
18141 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18142 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18143 return SWIG_Py_Void();
18144 }
18145
18146 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 return SWIG_Python_InitShadowInstance(args);
18148 }
18149
18150 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18151 PyObject *resultobj = 0;
18152 wxEventType result;
18153
18154 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18155 {
18156 PyThreadState* __tstate = wxPyBeginAllowThreads();
18157 result = (wxEventType)wxNewEventType();
18158 wxPyEndAllowThreads(__tstate);
18159 if (PyErr_Occurred()) SWIG_fail;
18160 }
18161 resultobj = SWIG_From_int(static_cast< int >(result));
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18169 PyObject *resultobj = 0;
18170 wxEvent *arg1 = (wxEvent *) 0 ;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18180 }
18181 arg1 = reinterpret_cast< wxEvent * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 delete arg1;
18185
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_Py_Void();
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj = 0;
18198 wxEvent *arg1 = (wxEvent *) 0 ;
18199 wxEventType arg2 ;
18200 void *argp1 = 0 ;
18201 int res1 = 0 ;
18202 int val2 ;
18203 int ecode2 = 0 ;
18204 PyObject * obj0 = 0 ;
18205 PyObject * obj1 = 0 ;
18206 char * kwnames[] = {
18207 (char *) "self",(char *) "typ", NULL
18208 };
18209
18210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18212 if (!SWIG_IsOK(res1)) {
18213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18214 }
18215 arg1 = reinterpret_cast< wxEvent * >(argp1);
18216 ecode2 = SWIG_AsVal_int(obj1, &val2);
18217 if (!SWIG_IsOK(ecode2)) {
18218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18219 }
18220 arg2 = static_cast< wxEventType >(val2);
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 (arg1)->SetEventType(arg2);
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 resultobj = SWIG_Py_Void();
18228 return resultobj;
18229 fail:
18230 return NULL;
18231 }
18232
18233
18234 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18235 PyObject *resultobj = 0;
18236 wxEvent *arg1 = (wxEvent *) 0 ;
18237 wxEventType result;
18238 void *argp1 = 0 ;
18239 int res1 = 0 ;
18240 PyObject *swig_obj[1] ;
18241
18242 if (!args) SWIG_fail;
18243 swig_obj[0] = args;
18244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18245 if (!SWIG_IsOK(res1)) {
18246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18247 }
18248 arg1 = reinterpret_cast< wxEvent * >(argp1);
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_From_int(static_cast< int >(result));
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18263 PyObject *resultobj = 0;
18264 wxEvent *arg1 = (wxEvent *) 0 ;
18265 wxObject *result = 0 ;
18266 void *argp1 = 0 ;
18267 int res1 = 0 ;
18268 PyObject *swig_obj[1] ;
18269
18270 if (!args) SWIG_fail;
18271 swig_obj[0] = args;
18272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18273 if (!SWIG_IsOK(res1)) {
18274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18275 }
18276 arg1 = reinterpret_cast< wxEvent * >(argp1);
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 {
18284 resultobj = wxPyMake_wxObject(result, (bool)0);
18285 }
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj = 0;
18294 wxEvent *arg1 = (wxEvent *) 0 ;
18295 wxObject *arg2 = (wxObject *) 0 ;
18296 void *argp1 = 0 ;
18297 int res1 = 0 ;
18298 void *argp2 = 0 ;
18299 int res2 = 0 ;
18300 PyObject * obj0 = 0 ;
18301 PyObject * obj1 = 0 ;
18302 char * kwnames[] = {
18303 (char *) "self",(char *) "obj", NULL
18304 };
18305
18306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18308 if (!SWIG_IsOK(res1)) {
18309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18310 }
18311 arg1 = reinterpret_cast< wxEvent * >(argp1);
18312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18313 if (!SWIG_IsOK(res2)) {
18314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18315 }
18316 arg2 = reinterpret_cast< wxObject * >(argp2);
18317 {
18318 PyThreadState* __tstate = wxPyBeginAllowThreads();
18319 (arg1)->SetEventObject(arg2);
18320 wxPyEndAllowThreads(__tstate);
18321 if (PyErr_Occurred()) SWIG_fail;
18322 }
18323 resultobj = SWIG_Py_Void();
18324 return resultobj;
18325 fail:
18326 return NULL;
18327 }
18328
18329
18330 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18331 PyObject *resultobj = 0;
18332 wxEvent *arg1 = (wxEvent *) 0 ;
18333 long result;
18334 void *argp1 = 0 ;
18335 int res1 = 0 ;
18336 PyObject *swig_obj[1] ;
18337
18338 if (!args) SWIG_fail;
18339 swig_obj[0] = args;
18340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18343 }
18344 arg1 = reinterpret_cast< wxEvent * >(argp1);
18345 {
18346 PyThreadState* __tstate = wxPyBeginAllowThreads();
18347 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18348 wxPyEndAllowThreads(__tstate);
18349 if (PyErr_Occurred()) SWIG_fail;
18350 }
18351 resultobj = SWIG_From_long(static_cast< long >(result));
18352 return resultobj;
18353 fail:
18354 return NULL;
18355 }
18356
18357
18358 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18359 PyObject *resultobj = 0;
18360 wxEvent *arg1 = (wxEvent *) 0 ;
18361 long arg2 = (long) 0 ;
18362 void *argp1 = 0 ;
18363 int res1 = 0 ;
18364 long val2 ;
18365 int ecode2 = 0 ;
18366 PyObject * obj0 = 0 ;
18367 PyObject * obj1 = 0 ;
18368 char * kwnames[] = {
18369 (char *) "self",(char *) "ts", NULL
18370 };
18371
18372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18374 if (!SWIG_IsOK(res1)) {
18375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18376 }
18377 arg1 = reinterpret_cast< wxEvent * >(argp1);
18378 if (obj1) {
18379 ecode2 = SWIG_AsVal_long(obj1, &val2);
18380 if (!SWIG_IsOK(ecode2)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18382 }
18383 arg2 = static_cast< long >(val2);
18384 }
18385 {
18386 PyThreadState* __tstate = wxPyBeginAllowThreads();
18387 (arg1)->SetTimestamp(arg2);
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 resultobj = SWIG_Py_Void();
18392 return resultobj;
18393 fail:
18394 return NULL;
18395 }
18396
18397
18398 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18399 PyObject *resultobj = 0;
18400 wxEvent *arg1 = (wxEvent *) 0 ;
18401 int result;
18402 void *argp1 = 0 ;
18403 int res1 = 0 ;
18404 PyObject *swig_obj[1] ;
18405
18406 if (!args) SWIG_fail;
18407 swig_obj[0] = args;
18408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18409 if (!SWIG_IsOK(res1)) {
18410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18411 }
18412 arg1 = reinterpret_cast< wxEvent * >(argp1);
18413 {
18414 PyThreadState* __tstate = wxPyBeginAllowThreads();
18415 result = (int)((wxEvent const *)arg1)->GetId();
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 resultobj = SWIG_From_int(static_cast< int >(result));
18420 return resultobj;
18421 fail:
18422 return NULL;
18423 }
18424
18425
18426 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18427 PyObject *resultobj = 0;
18428 wxEvent *arg1 = (wxEvent *) 0 ;
18429 int arg2 ;
18430 void *argp1 = 0 ;
18431 int res1 = 0 ;
18432 int val2 ;
18433 int ecode2 = 0 ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 char * kwnames[] = {
18437 (char *) "self",(char *) "Id", NULL
18438 };
18439
18440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 ecode2 = SWIG_AsVal_int(obj1, &val2);
18447 if (!SWIG_IsOK(ecode2)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18449 }
18450 arg2 = static_cast< int >(val2);
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 (arg1)->SetId(arg2);
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 resultobj = SWIG_Py_Void();
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18465 PyObject *resultobj = 0;
18466 wxEvent *arg1 = (wxEvent *) 0 ;
18467 bool result;
18468 void *argp1 = 0 ;
18469 int res1 = 0 ;
18470 PyObject *swig_obj[1] ;
18471
18472 if (!args) SWIG_fail;
18473 swig_obj[0] = args;
18474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18475 if (!SWIG_IsOK(res1)) {
18476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18477 }
18478 arg1 = reinterpret_cast< wxEvent * >(argp1);
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 {
18486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18487 }
18488 return resultobj;
18489 fail:
18490 return NULL;
18491 }
18492
18493
18494 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18495 PyObject *resultobj = 0;
18496 wxEvent *arg1 = (wxEvent *) 0 ;
18497 bool arg2 = (bool) true ;
18498 void *argp1 = 0 ;
18499 int res1 = 0 ;
18500 bool val2 ;
18501 int ecode2 = 0 ;
18502 PyObject * obj0 = 0 ;
18503 PyObject * obj1 = 0 ;
18504 char * kwnames[] = {
18505 (char *) "self",(char *) "skip", NULL
18506 };
18507
18508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18512 }
18513 arg1 = reinterpret_cast< wxEvent * >(argp1);
18514 if (obj1) {
18515 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18516 if (!SWIG_IsOK(ecode2)) {
18517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18518 }
18519 arg2 = static_cast< bool >(val2);
18520 }
18521 {
18522 PyThreadState* __tstate = wxPyBeginAllowThreads();
18523 (arg1)->Skip(arg2);
18524 wxPyEndAllowThreads(__tstate);
18525 if (PyErr_Occurred()) SWIG_fail;
18526 }
18527 resultobj = SWIG_Py_Void();
18528 return resultobj;
18529 fail:
18530 return NULL;
18531 }
18532
18533
18534 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18535 PyObject *resultobj = 0;
18536 wxEvent *arg1 = (wxEvent *) 0 ;
18537 bool result;
18538 void *argp1 = 0 ;
18539 int res1 = 0 ;
18540 PyObject *swig_obj[1] ;
18541
18542 if (!args) SWIG_fail;
18543 swig_obj[0] = args;
18544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18545 if (!SWIG_IsOK(res1)) {
18546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18547 }
18548 arg1 = reinterpret_cast< wxEvent * >(argp1);
18549 {
18550 PyThreadState* __tstate = wxPyBeginAllowThreads();
18551 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18557 }
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18565 PyObject *resultobj = 0;
18566 wxEvent *arg1 = (wxEvent *) 0 ;
18567 bool result;
18568 void *argp1 = 0 ;
18569 int res1 = 0 ;
18570 PyObject *swig_obj[1] ;
18571
18572 if (!args) SWIG_fail;
18573 swig_obj[0] = args;
18574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18577 }
18578 arg1 = reinterpret_cast< wxEvent * >(argp1);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 {
18586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxEvent *arg1 = (wxEvent *) 0 ;
18597 int result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18607 }
18608 arg1 = reinterpret_cast< wxEvent * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (int)(arg1)->StopPropagation();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_int(static_cast< int >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxEvent *arg1 = (wxEvent *) 0 ;
18625 int arg2 ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 int val2 ;
18629 int ecode2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "propagationLevel", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 ecode2 = SWIG_AsVal_int(obj1, &val2);
18643 if (!SWIG_IsOK(ecode2)) {
18644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18645 }
18646 arg2 = static_cast< int >(val2);
18647 {
18648 PyThreadState* __tstate = wxPyBeginAllowThreads();
18649 (arg1)->ResumePropagation(arg2);
18650 wxPyEndAllowThreads(__tstate);
18651 if (PyErr_Occurred()) SWIG_fail;
18652 }
18653 resultobj = SWIG_Py_Void();
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18661 PyObject *resultobj = 0;
18662 wxEvent *arg1 = (wxEvent *) 0 ;
18663 wxEvent *result = 0 ;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvent * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 result = (wxEvent *)(arg1)->Clone();
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18689 PyObject *obj;
18690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18691 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18692 return SWIG_Py_Void();
18693 }
18694
18695 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = 0;
18697 wxEvent *arg1 = 0 ;
18698 wxPropagationDisabler *result = 0 ;
18699 void *argp1 = 0 ;
18700 int res1 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 char * kwnames[] = {
18703 (char *) "event", NULL
18704 };
18705
18706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18707 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18708 if (!SWIG_IsOK(res1)) {
18709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18710 }
18711 if (!argp1) {
18712 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18713 }
18714 arg1 = reinterpret_cast< wxEvent * >(argp1);
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18722 return resultobj;
18723 fail:
18724 return NULL;
18725 }
18726
18727
18728 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18729 PyObject *resultobj = 0;
18730 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18731 void *argp1 = 0 ;
18732 int res1 = 0 ;
18733 PyObject *swig_obj[1] ;
18734
18735 if (!args) SWIG_fail;
18736 swig_obj[0] = args;
18737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18740 }
18741 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18742 {
18743 PyThreadState* __tstate = wxPyBeginAllowThreads();
18744 delete arg1;
18745
18746 wxPyEndAllowThreads(__tstate);
18747 if (PyErr_Occurred()) SWIG_fail;
18748 }
18749 resultobj = SWIG_Py_Void();
18750 return resultobj;
18751 fail:
18752 return NULL;
18753 }
18754
18755
18756 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18757 PyObject *obj;
18758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18759 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18760 return SWIG_Py_Void();
18761 }
18762
18763 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 return SWIG_Python_InitShadowInstance(args);
18765 }
18766
18767 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18768 PyObject *resultobj = 0;
18769 wxEvent *arg1 = 0 ;
18770 wxPropagateOnce *result = 0 ;
18771 void *argp1 = 0 ;
18772 int res1 = 0 ;
18773 PyObject * obj0 = 0 ;
18774 char * kwnames[] = {
18775 (char *) "event", NULL
18776 };
18777
18778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18779 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18780 if (!SWIG_IsOK(res1)) {
18781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18782 }
18783 if (!argp1) {
18784 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18785 }
18786 arg1 = reinterpret_cast< wxEvent * >(argp1);
18787 {
18788 PyThreadState* __tstate = wxPyBeginAllowThreads();
18789 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18790 wxPyEndAllowThreads(__tstate);
18791 if (PyErr_Occurred()) SWIG_fail;
18792 }
18793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18794 return resultobj;
18795 fail:
18796 return NULL;
18797 }
18798
18799
18800 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18801 PyObject *resultobj = 0;
18802 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 PyObject *swig_obj[1] ;
18806
18807 if (!args) SWIG_fail;
18808 swig_obj[0] = args;
18809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18810 if (!SWIG_IsOK(res1)) {
18811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18812 }
18813 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 delete arg1;
18817
18818 wxPyEndAllowThreads(__tstate);
18819 if (PyErr_Occurred()) SWIG_fail;
18820 }
18821 resultobj = SWIG_Py_Void();
18822 return resultobj;
18823 fail:
18824 return NULL;
18825 }
18826
18827
18828 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18829 PyObject *obj;
18830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18831 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18832 return SWIG_Py_Void();
18833 }
18834
18835 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18836 return SWIG_Python_InitShadowInstance(args);
18837 }
18838
18839 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18840 PyObject *resultobj = 0;
18841 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18842 int arg2 = (int) 0 ;
18843 wxCommandEvent *result = 0 ;
18844 int val1 ;
18845 int ecode1 = 0 ;
18846 int val2 ;
18847 int ecode2 = 0 ;
18848 PyObject * obj0 = 0 ;
18849 PyObject * obj1 = 0 ;
18850 char * kwnames[] = {
18851 (char *) "commandType",(char *) "winid", NULL
18852 };
18853
18854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18855 if (obj0) {
18856 ecode1 = SWIG_AsVal_int(obj0, &val1);
18857 if (!SWIG_IsOK(ecode1)) {
18858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18859 }
18860 arg1 = static_cast< wxEventType >(val1);
18861 }
18862 if (obj1) {
18863 ecode2 = SWIG_AsVal_int(obj1, &val2);
18864 if (!SWIG_IsOK(ecode2)) {
18865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18866 }
18867 arg2 = static_cast< int >(val2);
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18872 wxPyEndAllowThreads(__tstate);
18873 if (PyErr_Occurred()) SWIG_fail;
18874 }
18875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18876 return resultobj;
18877 fail:
18878 return NULL;
18879 }
18880
18881
18882 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18883 PyObject *resultobj = 0;
18884 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18885 int result;
18886 void *argp1 = 0 ;
18887 int res1 = 0 ;
18888 PyObject *swig_obj[1] ;
18889
18890 if (!args) SWIG_fail;
18891 swig_obj[0] = args;
18892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18893 if (!SWIG_IsOK(res1)) {
18894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18895 }
18896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_From_int(static_cast< int >(result));
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18913 wxString *arg2 = 0 ;
18914 void *argp1 = 0 ;
18915 int res1 = 0 ;
18916 bool temp2 = false ;
18917 PyObject * obj0 = 0 ;
18918 PyObject * obj1 = 0 ;
18919 char * kwnames[] = {
18920 (char *) "self",(char *) "s", NULL
18921 };
18922
18923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18925 if (!SWIG_IsOK(res1)) {
18926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18927 }
18928 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18929 {
18930 arg2 = wxString_in_helper(obj1);
18931 if (arg2 == NULL) SWIG_fail;
18932 temp2 = true;
18933 }
18934 {
18935 PyThreadState* __tstate = wxPyBeginAllowThreads();
18936 (arg1)->SetString((wxString const &)*arg2);
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 resultobj = SWIG_Py_Void();
18941 {
18942 if (temp2)
18943 delete arg2;
18944 }
18945 return resultobj;
18946 fail:
18947 {
18948 if (temp2)
18949 delete arg2;
18950 }
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *resultobj = 0;
18957 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18958 wxString result;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 PyObject *swig_obj[1] ;
18962
18963 if (!args) SWIG_fail;
18964 swig_obj[0] = args;
18965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18966 if (!SWIG_IsOK(res1)) {
18967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18968 }
18969 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 result = ((wxCommandEvent const *)arg1)->GetString();
18973 wxPyEndAllowThreads(__tstate);
18974 if (PyErr_Occurred()) SWIG_fail;
18975 }
18976 {
18977 #if wxUSE_UNICODE
18978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18979 #else
18980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18981 #endif
18982 }
18983 return resultobj;
18984 fail:
18985 return NULL;
18986 }
18987
18988
18989 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18990 PyObject *resultobj = 0;
18991 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18992 bool result;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 PyObject *swig_obj[1] ;
18996
18997 if (!args) SWIG_fail;
18998 swig_obj[0] = args;
18999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19000 if (!SWIG_IsOK(res1)) {
19001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19002 }
19003 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19007 wxPyEndAllowThreads(__tstate);
19008 if (PyErr_Occurred()) SWIG_fail;
19009 }
19010 {
19011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19012 }
19013 return resultobj;
19014 fail:
19015 return NULL;
19016 }
19017
19018
19019 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19020 PyObject *resultobj = 0;
19021 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19022 bool result;
19023 void *argp1 = 0 ;
19024 int res1 = 0 ;
19025 PyObject *swig_obj[1] ;
19026
19027 if (!args) SWIG_fail;
19028 swig_obj[0] = args;
19029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19030 if (!SWIG_IsOK(res1)) {
19031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19032 }
19033 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19037 wxPyEndAllowThreads(__tstate);
19038 if (PyErr_Occurred()) SWIG_fail;
19039 }
19040 {
19041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19042 }
19043 return resultobj;
19044 fail:
19045 return NULL;
19046 }
19047
19048
19049 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19050 PyObject *resultobj = 0;
19051 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19052 long arg2 ;
19053 void *argp1 = 0 ;
19054 int res1 = 0 ;
19055 long val2 ;
19056 int ecode2 = 0 ;
19057 PyObject * obj0 = 0 ;
19058 PyObject * obj1 = 0 ;
19059 char * kwnames[] = {
19060 (char *) "self",(char *) "extraLong", NULL
19061 };
19062
19063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19065 if (!SWIG_IsOK(res1)) {
19066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19067 }
19068 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19069 ecode2 = SWIG_AsVal_long(obj1, &val2);
19070 if (!SWIG_IsOK(ecode2)) {
19071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19072 }
19073 arg2 = static_cast< long >(val2);
19074 {
19075 PyThreadState* __tstate = wxPyBeginAllowThreads();
19076 (arg1)->SetExtraLong(arg2);
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 resultobj = SWIG_Py_Void();
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19088 PyObject *resultobj = 0;
19089 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19090 long result;
19091 void *argp1 = 0 ;
19092 int res1 = 0 ;
19093 PyObject *swig_obj[1] ;
19094
19095 if (!args) SWIG_fail;
19096 swig_obj[0] = args;
19097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19098 if (!SWIG_IsOK(res1)) {
19099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19100 }
19101 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19102 {
19103 PyThreadState* __tstate = wxPyBeginAllowThreads();
19104 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 resultobj = SWIG_From_long(static_cast< long >(result));
19109 return resultobj;
19110 fail:
19111 return NULL;
19112 }
19113
19114
19115 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19116 PyObject *resultobj = 0;
19117 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19118 int arg2 ;
19119 void *argp1 = 0 ;
19120 int res1 = 0 ;
19121 int val2 ;
19122 int ecode2 = 0 ;
19123 PyObject * obj0 = 0 ;
19124 PyObject * obj1 = 0 ;
19125 char * kwnames[] = {
19126 (char *) "self",(char *) "i", NULL
19127 };
19128
19129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19131 if (!SWIG_IsOK(res1)) {
19132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19133 }
19134 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19135 ecode2 = SWIG_AsVal_int(obj1, &val2);
19136 if (!SWIG_IsOK(ecode2)) {
19137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19138 }
19139 arg2 = static_cast< int >(val2);
19140 {
19141 PyThreadState* __tstate = wxPyBeginAllowThreads();
19142 (arg1)->SetInt(arg2);
19143 wxPyEndAllowThreads(__tstate);
19144 if (PyErr_Occurred()) SWIG_fail;
19145 }
19146 resultobj = SWIG_Py_Void();
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19154 PyObject *resultobj = 0;
19155 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19156 int result;
19157 void *argp1 = 0 ;
19158 int res1 = 0 ;
19159 PyObject *swig_obj[1] ;
19160
19161 if (!args) SWIG_fail;
19162 swig_obj[0] = args;
19163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19164 if (!SWIG_IsOK(res1)) {
19165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19166 }
19167 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_From_int(static_cast< int >(result));
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19182 PyObject *resultobj = 0;
19183 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19184 PyObject *result = 0 ;
19185 void *argp1 = 0 ;
19186 int res1 = 0 ;
19187 PyObject *swig_obj[1] ;
19188
19189 if (!args) SWIG_fail;
19190 swig_obj[0] = args;
19191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19192 if (!SWIG_IsOK(res1)) {
19193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19194 }
19195 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19199 wxPyEndAllowThreads(__tstate);
19200 if (PyErr_Occurred()) SWIG_fail;
19201 }
19202 resultobj = result;
19203 return resultobj;
19204 fail:
19205 return NULL;
19206 }
19207
19208
19209 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19210 PyObject *resultobj = 0;
19211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19212 PyObject *arg2 = (PyObject *) 0 ;
19213 void *argp1 = 0 ;
19214 int res1 = 0 ;
19215 PyObject * obj0 = 0 ;
19216 PyObject * obj1 = 0 ;
19217 char * kwnames[] = {
19218 (char *) "self",(char *) "clientData", NULL
19219 };
19220
19221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19223 if (!SWIG_IsOK(res1)) {
19224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19225 }
19226 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19227 arg2 = obj1;
19228 {
19229 PyThreadState* __tstate = wxPyBeginAllowThreads();
19230 wxCommandEvent_SetClientData(arg1,arg2);
19231 wxPyEndAllowThreads(__tstate);
19232 if (PyErr_Occurred()) SWIG_fail;
19233 }
19234 resultobj = SWIG_Py_Void();
19235 return resultobj;
19236 fail:
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19242 PyObject *resultobj = 0;
19243 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19244 wxEvent *result = 0 ;
19245 void *argp1 = 0 ;
19246 int res1 = 0 ;
19247 PyObject *swig_obj[1] ;
19248
19249 if (!args) SWIG_fail;
19250 swig_obj[0] = args;
19251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19252 if (!SWIG_IsOK(res1)) {
19253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19254 }
19255 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19270 PyObject *obj;
19271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19272 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19273 return SWIG_Py_Void();
19274 }
19275
19276 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19277 return SWIG_Python_InitShadowInstance(args);
19278 }
19279
19280 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19281 PyObject *resultobj = 0;
19282 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19283 int arg2 = (int) 0 ;
19284 wxNotifyEvent *result = 0 ;
19285 int val1 ;
19286 int ecode1 = 0 ;
19287 int val2 ;
19288 int ecode2 = 0 ;
19289 PyObject * obj0 = 0 ;
19290 PyObject * obj1 = 0 ;
19291 char * kwnames[] = {
19292 (char *) "commandType",(char *) "winid", NULL
19293 };
19294
19295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19296 if (obj0) {
19297 ecode1 = SWIG_AsVal_int(obj0, &val1);
19298 if (!SWIG_IsOK(ecode1)) {
19299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19300 }
19301 arg1 = static_cast< wxEventType >(val1);
19302 }
19303 if (obj1) {
19304 ecode2 = SWIG_AsVal_int(obj1, &val2);
19305 if (!SWIG_IsOK(ecode2)) {
19306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19307 }
19308 arg2 = static_cast< int >(val2);
19309 }
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19324 PyObject *resultobj = 0;
19325 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19326 void *argp1 = 0 ;
19327 int res1 = 0 ;
19328 PyObject *swig_obj[1] ;
19329
19330 if (!args) SWIG_fail;
19331 swig_obj[0] = args;
19332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19333 if (!SWIG_IsOK(res1)) {
19334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19335 }
19336 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 (arg1)->Veto();
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_Py_Void();
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19353 void *argp1 = 0 ;
19354 int res1 = 0 ;
19355 PyObject *swig_obj[1] ;
19356
19357 if (!args) SWIG_fail;
19358 swig_obj[0] = args;
19359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19360 if (!SWIG_IsOK(res1)) {
19361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19362 }
19363 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 (arg1)->Allow();
19367 wxPyEndAllowThreads(__tstate);
19368 if (PyErr_Occurred()) SWIG_fail;
19369 }
19370 resultobj = SWIG_Py_Void();
19371 return resultobj;
19372 fail:
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19378 PyObject *resultobj = 0;
19379 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19380 bool result;
19381 void *argp1 = 0 ;
19382 int res1 = 0 ;
19383 PyObject *swig_obj[1] ;
19384
19385 if (!args) SWIG_fail;
19386 swig_obj[0] = args;
19387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19388 if (!SWIG_IsOK(res1)) {
19389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19390 }
19391 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19392 {
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 result = (bool)(arg1)->IsAllowed();
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 {
19399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19400 }
19401 return resultobj;
19402 fail:
19403 return NULL;
19404 }
19405
19406
19407 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19408 PyObject *obj;
19409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19410 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19411 return SWIG_Py_Void();
19412 }
19413
19414 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19415 return SWIG_Python_InitShadowInstance(args);
19416 }
19417
19418 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19421 int arg2 = (int) 0 ;
19422 int arg3 = (int) 0 ;
19423 int arg4 = (int) 0 ;
19424 wxScrollEvent *result = 0 ;
19425 int val1 ;
19426 int ecode1 = 0 ;
19427 int val2 ;
19428 int ecode2 = 0 ;
19429 int val3 ;
19430 int ecode3 = 0 ;
19431 int val4 ;
19432 int ecode4 = 0 ;
19433 PyObject * obj0 = 0 ;
19434 PyObject * obj1 = 0 ;
19435 PyObject * obj2 = 0 ;
19436 PyObject * obj3 = 0 ;
19437 char * kwnames[] = {
19438 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19439 };
19440
19441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19442 if (obj0) {
19443 ecode1 = SWIG_AsVal_int(obj0, &val1);
19444 if (!SWIG_IsOK(ecode1)) {
19445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19446 }
19447 arg1 = static_cast< wxEventType >(val1);
19448 }
19449 if (obj1) {
19450 ecode2 = SWIG_AsVal_int(obj1, &val2);
19451 if (!SWIG_IsOK(ecode2)) {
19452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19453 }
19454 arg2 = static_cast< int >(val2);
19455 }
19456 if (obj2) {
19457 ecode3 = SWIG_AsVal_int(obj2, &val3);
19458 if (!SWIG_IsOK(ecode3)) {
19459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19460 }
19461 arg3 = static_cast< int >(val3);
19462 }
19463 if (obj3) {
19464 ecode4 = SWIG_AsVal_int(obj3, &val4);
19465 if (!SWIG_IsOK(ecode4)) {
19466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19467 }
19468 arg4 = static_cast< int >(val4);
19469 }
19470 {
19471 PyThreadState* __tstate = wxPyBeginAllowThreads();
19472 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19473 wxPyEndAllowThreads(__tstate);
19474 if (PyErr_Occurred()) SWIG_fail;
19475 }
19476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19477 return resultobj;
19478 fail:
19479 return NULL;
19480 }
19481
19482
19483 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19484 PyObject *resultobj = 0;
19485 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19486 int result;
19487 void *argp1 = 0 ;
19488 int res1 = 0 ;
19489 PyObject *swig_obj[1] ;
19490
19491 if (!args) SWIG_fail;
19492 swig_obj[0] = args;
19493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19494 if (!SWIG_IsOK(res1)) {
19495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19496 }
19497 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19498 {
19499 PyThreadState* __tstate = wxPyBeginAllowThreads();
19500 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19501 wxPyEndAllowThreads(__tstate);
19502 if (PyErr_Occurred()) SWIG_fail;
19503 }
19504 resultobj = SWIG_From_int(static_cast< int >(result));
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19512 PyObject *resultobj = 0;
19513 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19514 int result;
19515 void *argp1 = 0 ;
19516 int res1 = 0 ;
19517 PyObject *swig_obj[1] ;
19518
19519 if (!args) SWIG_fail;
19520 swig_obj[0] = args;
19521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19522 if (!SWIG_IsOK(res1)) {
19523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19524 }
19525 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19526 {
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 resultobj = SWIG_From_int(static_cast< int >(result));
19533 return resultobj;
19534 fail:
19535 return NULL;
19536 }
19537
19538
19539 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19540 PyObject *resultobj = 0;
19541 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19542 int arg2 ;
19543 void *argp1 = 0 ;
19544 int res1 = 0 ;
19545 int val2 ;
19546 int ecode2 = 0 ;
19547 PyObject * obj0 = 0 ;
19548 PyObject * obj1 = 0 ;
19549 char * kwnames[] = {
19550 (char *) "self",(char *) "orient", NULL
19551 };
19552
19553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19555 if (!SWIG_IsOK(res1)) {
19556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19557 }
19558 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19559 ecode2 = SWIG_AsVal_int(obj1, &val2);
19560 if (!SWIG_IsOK(ecode2)) {
19561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19562 }
19563 arg2 = static_cast< int >(val2);
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 (arg1)->SetOrientation(arg2);
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_Py_Void();
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj = 0;
19579 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19580 int arg2 ;
19581 void *argp1 = 0 ;
19582 int res1 = 0 ;
19583 int val2 ;
19584 int ecode2 = 0 ;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 char * kwnames[] = {
19588 (char *) "self",(char *) "pos", NULL
19589 };
19590
19591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19593 if (!SWIG_IsOK(res1)) {
19594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19595 }
19596 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19597 ecode2 = SWIG_AsVal_int(obj1, &val2);
19598 if (!SWIG_IsOK(ecode2)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19600 }
19601 arg2 = static_cast< int >(val2);
19602 {
19603 PyThreadState* __tstate = wxPyBeginAllowThreads();
19604 (arg1)->SetPosition(arg2);
19605 wxPyEndAllowThreads(__tstate);
19606 if (PyErr_Occurred()) SWIG_fail;
19607 }
19608 resultobj = SWIG_Py_Void();
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19616 PyObject *obj;
19617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19618 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19619 return SWIG_Py_Void();
19620 }
19621
19622 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19623 return SWIG_Python_InitShadowInstance(args);
19624 }
19625
19626 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19629 int arg2 = (int) 0 ;
19630 int arg3 = (int) 0 ;
19631 wxScrollWinEvent *result = 0 ;
19632 int val1 ;
19633 int ecode1 = 0 ;
19634 int val2 ;
19635 int ecode2 = 0 ;
19636 int val3 ;
19637 int ecode3 = 0 ;
19638 PyObject * obj0 = 0 ;
19639 PyObject * obj1 = 0 ;
19640 PyObject * obj2 = 0 ;
19641 char * kwnames[] = {
19642 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19643 };
19644
19645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19646 if (obj0) {
19647 ecode1 = SWIG_AsVal_int(obj0, &val1);
19648 if (!SWIG_IsOK(ecode1)) {
19649 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19650 }
19651 arg1 = static_cast< wxEventType >(val1);
19652 }
19653 if (obj1) {
19654 ecode2 = SWIG_AsVal_int(obj1, &val2);
19655 if (!SWIG_IsOK(ecode2)) {
19656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19657 }
19658 arg2 = static_cast< int >(val2);
19659 }
19660 if (obj2) {
19661 ecode3 = SWIG_AsVal_int(obj2, &val3);
19662 if (!SWIG_IsOK(ecode3)) {
19663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19664 }
19665 arg3 = static_cast< int >(val3);
19666 }
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19681 PyObject *resultobj = 0;
19682 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19683 int result;
19684 void *argp1 = 0 ;
19685 int res1 = 0 ;
19686 PyObject *swig_obj[1] ;
19687
19688 if (!args) SWIG_fail;
19689 swig_obj[0] = args;
19690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19691 if (!SWIG_IsOK(res1)) {
19692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19693 }
19694 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19698 wxPyEndAllowThreads(__tstate);
19699 if (PyErr_Occurred()) SWIG_fail;
19700 }
19701 resultobj = SWIG_From_int(static_cast< int >(result));
19702 return resultobj;
19703 fail:
19704 return NULL;
19705 }
19706
19707
19708 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19709 PyObject *resultobj = 0;
19710 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19711 int result;
19712 void *argp1 = 0 ;
19713 int res1 = 0 ;
19714 PyObject *swig_obj[1] ;
19715
19716 if (!args) SWIG_fail;
19717 swig_obj[0] = args;
19718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19719 if (!SWIG_IsOK(res1)) {
19720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19721 }
19722 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19726 wxPyEndAllowThreads(__tstate);
19727 if (PyErr_Occurred()) SWIG_fail;
19728 }
19729 resultobj = SWIG_From_int(static_cast< int >(result));
19730 return resultobj;
19731 fail:
19732 return NULL;
19733 }
19734
19735
19736 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj = 0;
19738 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19739 int arg2 ;
19740 void *argp1 = 0 ;
19741 int res1 = 0 ;
19742 int val2 ;
19743 int ecode2 = 0 ;
19744 PyObject * obj0 = 0 ;
19745 PyObject * obj1 = 0 ;
19746 char * kwnames[] = {
19747 (char *) "self",(char *) "orient", NULL
19748 };
19749
19750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19752 if (!SWIG_IsOK(res1)) {
19753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19754 }
19755 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19756 ecode2 = SWIG_AsVal_int(obj1, &val2);
19757 if (!SWIG_IsOK(ecode2)) {
19758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19759 }
19760 arg2 = static_cast< int >(val2);
19761 {
19762 PyThreadState* __tstate = wxPyBeginAllowThreads();
19763 (arg1)->SetOrientation(arg2);
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 resultobj = SWIG_Py_Void();
19768 return resultobj;
19769 fail:
19770 return NULL;
19771 }
19772
19773
19774 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj = 0;
19776 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19777 int arg2 ;
19778 void *argp1 = 0 ;
19779 int res1 = 0 ;
19780 int val2 ;
19781 int ecode2 = 0 ;
19782 PyObject * obj0 = 0 ;
19783 PyObject * obj1 = 0 ;
19784 char * kwnames[] = {
19785 (char *) "self",(char *) "pos", NULL
19786 };
19787
19788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19790 if (!SWIG_IsOK(res1)) {
19791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19792 }
19793 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19794 ecode2 = SWIG_AsVal_int(obj1, &val2);
19795 if (!SWIG_IsOK(ecode2)) {
19796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19797 }
19798 arg2 = static_cast< int >(val2);
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 (arg1)->SetPosition(arg2);
19802 wxPyEndAllowThreads(__tstate);
19803 if (PyErr_Occurred()) SWIG_fail;
19804 }
19805 resultobj = SWIG_Py_Void();
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19813 PyObject *obj;
19814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19815 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19816 return SWIG_Py_Void();
19817 }
19818
19819 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19820 return SWIG_Python_InitShadowInstance(args);
19821 }
19822
19823 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19826 wxMouseEvent *result = 0 ;
19827 int val1 ;
19828 int ecode1 = 0 ;
19829 PyObject * obj0 = 0 ;
19830 char * kwnames[] = {
19831 (char *) "mouseType", NULL
19832 };
19833
19834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19835 if (obj0) {
19836 ecode1 = SWIG_AsVal_int(obj0, &val1);
19837 if (!SWIG_IsOK(ecode1)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19839 }
19840 arg1 = static_cast< wxEventType >(val1);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 {
19849 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19850 }
19851 return resultobj;
19852 fail:
19853 return NULL;
19854 }
19855
19856
19857 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19858 PyObject *resultobj = 0;
19859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19860 bool result;
19861 void *argp1 = 0 ;
19862 int res1 = 0 ;
19863 PyObject *swig_obj[1] ;
19864
19865 if (!args) SWIG_fail;
19866 swig_obj[0] = args;
19867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19868 if (!SWIG_IsOK(res1)) {
19869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19870 }
19871 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19872 {
19873 PyThreadState* __tstate = wxPyBeginAllowThreads();
19874 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 {
19879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19880 }
19881 return resultobj;
19882 fail:
19883 return NULL;
19884 }
19885
19886
19887 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19888 PyObject *resultobj = 0;
19889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19890 int arg2 = (int) wxMOUSE_BTN_ANY ;
19891 bool result;
19892 void *argp1 = 0 ;
19893 int res1 = 0 ;
19894 int val2 ;
19895 int ecode2 = 0 ;
19896 PyObject * obj0 = 0 ;
19897 PyObject * obj1 = 0 ;
19898 char * kwnames[] = {
19899 (char *) "self",(char *) "but", NULL
19900 };
19901
19902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19904 if (!SWIG_IsOK(res1)) {
19905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19906 }
19907 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19908 if (obj1) {
19909 ecode2 = SWIG_AsVal_int(obj1, &val2);
19910 if (!SWIG_IsOK(ecode2)) {
19911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19912 }
19913 arg2 = static_cast< int >(val2);
19914 }
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19918 wxPyEndAllowThreads(__tstate);
19919 if (PyErr_Occurred()) SWIG_fail;
19920 }
19921 {
19922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19923 }
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj = 0;
19932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19933 int arg2 = (int) wxMOUSE_BTN_ANY ;
19934 bool result;
19935 void *argp1 = 0 ;
19936 int res1 = 0 ;
19937 int val2 ;
19938 int ecode2 = 0 ;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 char * kwnames[] = {
19942 (char *) "self",(char *) "but", NULL
19943 };
19944
19945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19947 if (!SWIG_IsOK(res1)) {
19948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19949 }
19950 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19951 if (obj1) {
19952 ecode2 = SWIG_AsVal_int(obj1, &val2);
19953 if (!SWIG_IsOK(ecode2)) {
19954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19955 }
19956 arg2 = static_cast< int >(val2);
19957 }
19958 {
19959 PyThreadState* __tstate = wxPyBeginAllowThreads();
19960 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 {
19965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19966 }
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19974 PyObject *resultobj = 0;
19975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19976 int arg2 = (int) wxMOUSE_BTN_ANY ;
19977 bool result;
19978 void *argp1 = 0 ;
19979 int res1 = 0 ;
19980 int val2 ;
19981 int ecode2 = 0 ;
19982 PyObject * obj0 = 0 ;
19983 PyObject * obj1 = 0 ;
19984 char * kwnames[] = {
19985 (char *) "self",(char *) "but", NULL
19986 };
19987
19988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19990 if (!SWIG_IsOK(res1)) {
19991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19992 }
19993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19994 if (obj1) {
19995 ecode2 = SWIG_AsVal_int(obj1, &val2);
19996 if (!SWIG_IsOK(ecode2)) {
19997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19998 }
19999 arg2 = static_cast< int >(val2);
20000 }
20001 {
20002 PyThreadState* __tstate = wxPyBeginAllowThreads();
20003 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20004 wxPyEndAllowThreads(__tstate);
20005 if (PyErr_Occurred()) SWIG_fail;
20006 }
20007 {
20008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20009 }
20010 return resultobj;
20011 fail:
20012 return NULL;
20013 }
20014
20015
20016 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj = 0;
20018 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20019 int arg2 ;
20020 bool result;
20021 void *argp1 = 0 ;
20022 int res1 = 0 ;
20023 int val2 ;
20024 int ecode2 = 0 ;
20025 PyObject * obj0 = 0 ;
20026 PyObject * obj1 = 0 ;
20027 char * kwnames[] = {
20028 (char *) "self",(char *) "button", NULL
20029 };
20030
20031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20033 if (!SWIG_IsOK(res1)) {
20034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20035 }
20036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20037 ecode2 = SWIG_AsVal_int(obj1, &val2);
20038 if (!SWIG_IsOK(ecode2)) {
20039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20040 }
20041 arg2 = static_cast< int >(val2);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 {
20049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20050 }
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj = 0;
20059 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20060 int arg2 ;
20061 bool result;
20062 void *argp1 = 0 ;
20063 int res1 = 0 ;
20064 int val2 ;
20065 int ecode2 = 0 ;
20066 PyObject * obj0 = 0 ;
20067 PyObject * obj1 = 0 ;
20068 char * kwnames[] = {
20069 (char *) "self",(char *) "but", NULL
20070 };
20071
20072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20074 if (!SWIG_IsOK(res1)) {
20075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20076 }
20077 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20078 ecode2 = SWIG_AsVal_int(obj1, &val2);
20079 if (!SWIG_IsOK(ecode2)) {
20080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20081 }
20082 arg2 = static_cast< int >(val2);
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 {
20090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20091 }
20092 return resultobj;
20093 fail:
20094 return NULL;
20095 }
20096
20097
20098 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20099 PyObject *resultobj = 0;
20100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20101 int result;
20102 void *argp1 = 0 ;
20103 int res1 = 0 ;
20104 PyObject *swig_obj[1] ;
20105
20106 if (!args) SWIG_fail;
20107 swig_obj[0] = args;
20108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20109 if (!SWIG_IsOK(res1)) {
20110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20111 }
20112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 resultobj = SWIG_From_int(static_cast< int >(result));
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20127 PyObject *resultobj = 0;
20128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20129 bool result;
20130 void *argp1 = 0 ;
20131 int res1 = 0 ;
20132 PyObject *swig_obj[1] ;
20133
20134 if (!args) SWIG_fail;
20135 swig_obj[0] = args;
20136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20137 if (!SWIG_IsOK(res1)) {
20138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20139 }
20140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20141 {
20142 PyThreadState* __tstate = wxPyBeginAllowThreads();
20143 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20144 wxPyEndAllowThreads(__tstate);
20145 if (PyErr_Occurred()) SWIG_fail;
20146 }
20147 {
20148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20149 }
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20157 PyObject *resultobj = 0;
20158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20159 bool result;
20160 void *argp1 = 0 ;
20161 int res1 = 0 ;
20162 PyObject *swig_obj[1] ;
20163
20164 if (!args) SWIG_fail;
20165 swig_obj[0] = args;
20166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20167 if (!SWIG_IsOK(res1)) {
20168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20169 }
20170 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 {
20178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20179 }
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20187 PyObject *resultobj = 0;
20188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20189 bool result;
20190 void *argp1 = 0 ;
20191 int res1 = 0 ;
20192 PyObject *swig_obj[1] ;
20193
20194 if (!args) SWIG_fail;
20195 swig_obj[0] = args;
20196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20197 if (!SWIG_IsOK(res1)) {
20198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20199 }
20200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20201 {
20202 PyThreadState* __tstate = wxPyBeginAllowThreads();
20203 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20204 wxPyEndAllowThreads(__tstate);
20205 if (PyErr_Occurred()) SWIG_fail;
20206 }
20207 {
20208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20209 }
20210 return resultobj;
20211 fail:
20212 return NULL;
20213 }
20214
20215
20216 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *resultobj = 0;
20218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20219 bool result;
20220 void *argp1 = 0 ;
20221 int res1 = 0 ;
20222 PyObject *swig_obj[1] ;
20223
20224 if (!args) SWIG_fail;
20225 swig_obj[0] = args;
20226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20227 if (!SWIG_IsOK(res1)) {
20228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20229 }
20230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20234 wxPyEndAllowThreads(__tstate);
20235 if (PyErr_Occurred()) SWIG_fail;
20236 }
20237 {
20238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20239 }
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 PyObject *resultobj = 0;
20248 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20249 bool result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 PyObject *swig_obj[1] ;
20253
20254 if (!args) SWIG_fail;
20255 swig_obj[0] = args;
20256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20257 if (!SWIG_IsOK(res1)) {
20258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20259 }
20260 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 {
20268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20269 }
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *resultobj = 0;
20278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20279 bool result;
20280 void *argp1 = 0 ;
20281 int res1 = 0 ;
20282 PyObject *swig_obj[1] ;
20283
20284 if (!args) SWIG_fail;
20285 swig_obj[0] = args;
20286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20287 if (!SWIG_IsOK(res1)) {
20288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20289 }
20290 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 {
20298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20299 }
20300 return resultobj;
20301 fail:
20302 return NULL;
20303 }
20304
20305
20306 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20307 PyObject *resultobj = 0;
20308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20309 bool result;
20310 void *argp1 = 0 ;
20311 int res1 = 0 ;
20312 PyObject *swig_obj[1] ;
20313
20314 if (!args) SWIG_fail;
20315 swig_obj[0] = args;
20316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20317 if (!SWIG_IsOK(res1)) {
20318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20319 }
20320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 {
20328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20329 }
20330 return resultobj;
20331 fail:
20332 return NULL;
20333 }
20334
20335
20336 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20337 PyObject *resultobj = 0;
20338 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20339 bool result;
20340 void *argp1 = 0 ;
20341 int res1 = 0 ;
20342 PyObject *swig_obj[1] ;
20343
20344 if (!args) SWIG_fail;
20345 swig_obj[0] = args;
20346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20347 if (!SWIG_IsOK(res1)) {
20348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20349 }
20350 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20351 {
20352 PyThreadState* __tstate = wxPyBeginAllowThreads();
20353 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20354 wxPyEndAllowThreads(__tstate);
20355 if (PyErr_Occurred()) SWIG_fail;
20356 }
20357 {
20358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20359 }
20360 return resultobj;
20361 fail:
20362 return NULL;
20363 }
20364
20365
20366 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20367 PyObject *resultobj = 0;
20368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20369 bool result;
20370 void *argp1 = 0 ;
20371 int res1 = 0 ;
20372 PyObject *swig_obj[1] ;
20373
20374 if (!args) SWIG_fail;
20375 swig_obj[0] = args;
20376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20377 if (!SWIG_IsOK(res1)) {
20378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20379 }
20380 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 {
20388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20389 }
20390 return resultobj;
20391 fail:
20392 return NULL;
20393 }
20394
20395
20396 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 PyObject *resultobj = 0;
20398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20399 bool result;
20400 void *argp1 = 0 ;
20401 int res1 = 0 ;
20402 PyObject *swig_obj[1] ;
20403
20404 if (!args) SWIG_fail;
20405 swig_obj[0] = args;
20406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20407 if (!SWIG_IsOK(res1)) {
20408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20409 }
20410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20411 {
20412 PyThreadState* __tstate = wxPyBeginAllowThreads();
20413 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 {
20418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20419 }
20420 return resultobj;
20421 fail:
20422 return NULL;
20423 }
20424
20425
20426 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20427 PyObject *resultobj = 0;
20428 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20429 bool result;
20430 void *argp1 = 0 ;
20431 int res1 = 0 ;
20432 PyObject *swig_obj[1] ;
20433
20434 if (!args) SWIG_fail;
20435 swig_obj[0] = args;
20436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20437 if (!SWIG_IsOK(res1)) {
20438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20439 }
20440 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20444 wxPyEndAllowThreads(__tstate);
20445 if (PyErr_Occurred()) SWIG_fail;
20446 }
20447 {
20448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20449 }
20450 return resultobj;
20451 fail:
20452 return NULL;
20453 }
20454
20455
20456 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 PyObject *resultobj = 0;
20458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20459 bool result;
20460 void *argp1 = 0 ;
20461 int res1 = 0 ;
20462 PyObject *swig_obj[1] ;
20463
20464 if (!args) SWIG_fail;
20465 swig_obj[0] = args;
20466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20467 if (!SWIG_IsOK(res1)) {
20468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20469 }
20470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20474 wxPyEndAllowThreads(__tstate);
20475 if (PyErr_Occurred()) SWIG_fail;
20476 }
20477 {
20478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20479 }
20480 return resultobj;
20481 fail:
20482 return NULL;
20483 }
20484
20485
20486 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20487 PyObject *resultobj = 0;
20488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20489 bool result;
20490 void *argp1 = 0 ;
20491 int res1 = 0 ;
20492 PyObject *swig_obj[1] ;
20493
20494 if (!args) SWIG_fail;
20495 swig_obj[0] = args;
20496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20497 if (!SWIG_IsOK(res1)) {
20498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20499 }
20500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20504 wxPyEndAllowThreads(__tstate);
20505 if (PyErr_Occurred()) SWIG_fail;
20506 }
20507 {
20508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20509 }
20510 return resultobj;
20511 fail:
20512 return NULL;
20513 }
20514
20515
20516 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20517 PyObject *resultobj = 0;
20518 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20519 bool result;
20520 void *argp1 = 0 ;
20521 int res1 = 0 ;
20522 PyObject *swig_obj[1] ;
20523
20524 if (!args) SWIG_fail;
20525 swig_obj[0] = args;
20526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20527 if (!SWIG_IsOK(res1)) {
20528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20529 }
20530 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20531 {
20532 PyThreadState* __tstate = wxPyBeginAllowThreads();
20533 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20534 wxPyEndAllowThreads(__tstate);
20535 if (PyErr_Occurred()) SWIG_fail;
20536 }
20537 {
20538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20539 }
20540 return resultobj;
20541 fail:
20542 return NULL;
20543 }
20544
20545
20546 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20547 PyObject *resultobj = 0;
20548 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20549 bool result;
20550 void *argp1 = 0 ;
20551 int res1 = 0 ;
20552 PyObject *swig_obj[1] ;
20553
20554 if (!args) SWIG_fail;
20555 swig_obj[0] = args;
20556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20559 }
20560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)(arg1)->LeftIsDown();
20564 wxPyEndAllowThreads(__tstate);
20565 if (PyErr_Occurred()) SWIG_fail;
20566 }
20567 {
20568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20569 }
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20577 PyObject *resultobj = 0;
20578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20579 bool result;
20580 void *argp1 = 0 ;
20581 int res1 = 0 ;
20582 PyObject *swig_obj[1] ;
20583
20584 if (!args) SWIG_fail;
20585 swig_obj[0] = args;
20586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20587 if (!SWIG_IsOK(res1)) {
20588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20589 }
20590 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20591 {
20592 PyThreadState* __tstate = wxPyBeginAllowThreads();
20593 result = (bool)(arg1)->MiddleIsDown();
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20607 PyObject *resultobj = 0;
20608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20609 bool result;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 PyObject *swig_obj[1] ;
20613
20614 if (!args) SWIG_fail;
20615 swig_obj[0] = args;
20616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20617 if (!SWIG_IsOK(res1)) {
20618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20619 }
20620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20621 {
20622 PyThreadState* __tstate = wxPyBeginAllowThreads();
20623 result = (bool)(arg1)->RightIsDown();
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 {
20628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20629 }
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20637 PyObject *resultobj = 0;
20638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20639 bool result;
20640 void *argp1 = 0 ;
20641 int res1 = 0 ;
20642 PyObject *swig_obj[1] ;
20643
20644 if (!args) SWIG_fail;
20645 swig_obj[0] = args;
20646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20647 if (!SWIG_IsOK(res1)) {
20648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20649 }
20650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20651 {
20652 PyThreadState* __tstate = wxPyBeginAllowThreads();
20653 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20667 PyObject *resultobj = 0;
20668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20669 bool result;
20670 void *argp1 = 0 ;
20671 int res1 = 0 ;
20672 PyObject *swig_obj[1] ;
20673
20674 if (!args) SWIG_fail;
20675 swig_obj[0] = args;
20676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20677 if (!SWIG_IsOK(res1)) {
20678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20679 }
20680 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20684 wxPyEndAllowThreads(__tstate);
20685 if (PyErr_Occurred()) SWIG_fail;
20686 }
20687 {
20688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20689 }
20690 return resultobj;
20691 fail:
20692 return NULL;
20693 }
20694
20695
20696 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20697 PyObject *resultobj = 0;
20698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20699 bool result;
20700 void *argp1 = 0 ;
20701 int res1 = 0 ;
20702 PyObject *swig_obj[1] ;
20703
20704 if (!args) SWIG_fail;
20705 swig_obj[0] = args;
20706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20707 if (!SWIG_IsOK(res1)) {
20708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20709 }
20710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 {
20718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20719 }
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20727 PyObject *resultobj = 0;
20728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20729 bool result;
20730 void *argp1 = 0 ;
20731 int res1 = 0 ;
20732 PyObject *swig_obj[1] ;
20733
20734 if (!args) SWIG_fail;
20735 swig_obj[0] = args;
20736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20739 }
20740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 {
20748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20749 }
20750 return resultobj;
20751 fail:
20752 return NULL;
20753 }
20754
20755
20756 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20757 PyObject *resultobj = 0;
20758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20759 wxPoint result;
20760 void *argp1 = 0 ;
20761 int res1 = 0 ;
20762 PyObject *swig_obj[1] ;
20763
20764 if (!args) SWIG_fail;
20765 swig_obj[0] = args;
20766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20767 if (!SWIG_IsOK(res1)) {
20768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20769 }
20770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (arg1)->GetPosition();
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20785 PyObject *resultobj = 0;
20786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20787 long *arg2 = (long *) 0 ;
20788 long *arg3 = (long *) 0 ;
20789 void *argp1 = 0 ;
20790 int res1 = 0 ;
20791 long temp2 ;
20792 int res2 = SWIG_TMPOBJ ;
20793 long temp3 ;
20794 int res3 = SWIG_TMPOBJ ;
20795 PyObject *swig_obj[1] ;
20796
20797 arg2 = &temp2;
20798 arg3 = &temp3;
20799 if (!args) SWIG_fail;
20800 swig_obj[0] = args;
20801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20802 if (!SWIG_IsOK(res1)) {
20803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20804 }
20805 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20806 {
20807 PyThreadState* __tstate = wxPyBeginAllowThreads();
20808 (arg1)->GetPosition(arg2,arg3);
20809 wxPyEndAllowThreads(__tstate);
20810 if (PyErr_Occurred()) SWIG_fail;
20811 }
20812 resultobj = SWIG_Py_Void();
20813 if (SWIG_IsTmpObj(res2)) {
20814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20815 } else {
20816 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20818 }
20819 if (SWIG_IsTmpObj(res3)) {
20820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20821 } else {
20822 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20824 }
20825 return resultobj;
20826 fail:
20827 return NULL;
20828 }
20829
20830
20831 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20832 PyObject *resultobj = 0;
20833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20834 wxDC *arg2 = 0 ;
20835 wxPoint result;
20836 void *argp1 = 0 ;
20837 int res1 = 0 ;
20838 void *argp2 = 0 ;
20839 int res2 = 0 ;
20840 PyObject * obj0 = 0 ;
20841 PyObject * obj1 = 0 ;
20842 char * kwnames[] = {
20843 (char *) "self",(char *) "dc", NULL
20844 };
20845
20846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20848 if (!SWIG_IsOK(res1)) {
20849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20850 }
20851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20852 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20853 if (!SWIG_IsOK(res2)) {
20854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20855 }
20856 if (!argp2) {
20857 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20858 }
20859 arg2 = reinterpret_cast< wxDC * >(argp2);
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20863 wxPyEndAllowThreads(__tstate);
20864 if (PyErr_Occurred()) SWIG_fail;
20865 }
20866 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20874 PyObject *resultobj = 0;
20875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20876 int result;
20877 void *argp1 = 0 ;
20878 int res1 = 0 ;
20879 PyObject *swig_obj[1] ;
20880
20881 if (!args) SWIG_fail;
20882 swig_obj[0] = args;
20883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20884 if (!SWIG_IsOK(res1)) {
20885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20886 }
20887 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20888 {
20889 PyThreadState* __tstate = wxPyBeginAllowThreads();
20890 result = (int)((wxMouseEvent const *)arg1)->GetX();
20891 wxPyEndAllowThreads(__tstate);
20892 if (PyErr_Occurred()) SWIG_fail;
20893 }
20894 resultobj = SWIG_From_int(static_cast< int >(result));
20895 return resultobj;
20896 fail:
20897 return NULL;
20898 }
20899
20900
20901 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20902 PyObject *resultobj = 0;
20903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20904 int result;
20905 void *argp1 = 0 ;
20906 int res1 = 0 ;
20907 PyObject *swig_obj[1] ;
20908
20909 if (!args) SWIG_fail;
20910 swig_obj[0] = args;
20911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20912 if (!SWIG_IsOK(res1)) {
20913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20914 }
20915 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (int)((wxMouseEvent const *)arg1)->GetY();
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_From_int(static_cast< int >(result));
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *resultobj = 0;
20931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20932 int result;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20942 }
20943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_From_int(static_cast< int >(result));
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *resultobj = 0;
20959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20960 int result;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 PyObject *swig_obj[1] ;
20964
20965 if (!args) SWIG_fail;
20966 swig_obj[0] = args;
20967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20970 }
20971 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 resultobj = SWIG_From_int(static_cast< int >(result));
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20986 PyObject *resultobj = 0;
20987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20988 int result;
20989 void *argp1 = 0 ;
20990 int res1 = 0 ;
20991 PyObject *swig_obj[1] ;
20992
20993 if (!args) SWIG_fail;
20994 swig_obj[0] = args;
20995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20996 if (!SWIG_IsOK(res1)) {
20997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20998 }
20999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_From_int(static_cast< int >(result));
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21016 bool result;
21017 void *argp1 = 0 ;
21018 int res1 = 0 ;
21019 PyObject *swig_obj[1] ;
21020
21021 if (!args) SWIG_fail;
21022 swig_obj[0] = args;
21023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21026 }
21027 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21031 wxPyEndAllowThreads(__tstate);
21032 if (PyErr_Occurred()) SWIG_fail;
21033 }
21034 {
21035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21036 }
21037 return resultobj;
21038 fail:
21039 return NULL;
21040 }
21041
21042
21043 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 PyObject *resultobj = 0;
21045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21046 int arg2 ;
21047 void *argp1 = 0 ;
21048 int res1 = 0 ;
21049 int val2 ;
21050 int ecode2 = 0 ;
21051 PyObject *swig_obj[2] ;
21052
21053 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21057 }
21058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21059 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21060 if (!SWIG_IsOK(ecode2)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21062 }
21063 arg2 = static_cast< int >(val2);
21064 if (arg1) (arg1)->m_x = arg2;
21065
21066 resultobj = SWIG_Py_Void();
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *resultobj = 0;
21075 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21076 int result;
21077 void *argp1 = 0 ;
21078 int res1 = 0 ;
21079 PyObject *swig_obj[1] ;
21080
21081 if (!args) SWIG_fail;
21082 swig_obj[0] = args;
21083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21084 if (!SWIG_IsOK(res1)) {
21085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21086 }
21087 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21088 result = (int) ((arg1)->m_x);
21089 resultobj = SWIG_From_int(static_cast< int >(result));
21090 return resultobj;
21091 fail:
21092 return NULL;
21093 }
21094
21095
21096 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21097 PyObject *resultobj = 0;
21098 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21099 int arg2 ;
21100 void *argp1 = 0 ;
21101 int res1 = 0 ;
21102 int val2 ;
21103 int ecode2 = 0 ;
21104 PyObject *swig_obj[2] ;
21105
21106 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21110 }
21111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21112 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21113 if (!SWIG_IsOK(ecode2)) {
21114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21115 }
21116 arg2 = static_cast< int >(val2);
21117 if (arg1) (arg1)->m_y = arg2;
21118
21119 resultobj = SWIG_Py_Void();
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 PyObject *resultobj = 0;
21128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21129 int result;
21130 void *argp1 = 0 ;
21131 int res1 = 0 ;
21132 PyObject *swig_obj[1] ;
21133
21134 if (!args) SWIG_fail;
21135 swig_obj[0] = args;
21136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21137 if (!SWIG_IsOK(res1)) {
21138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21139 }
21140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21141 result = (int) ((arg1)->m_y);
21142 resultobj = SWIG_From_int(static_cast< int >(result));
21143 return resultobj;
21144 fail:
21145 return NULL;
21146 }
21147
21148
21149 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21150 PyObject *resultobj = 0;
21151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21152 bool arg2 ;
21153 void *argp1 = 0 ;
21154 int res1 = 0 ;
21155 bool val2 ;
21156 int ecode2 = 0 ;
21157 PyObject *swig_obj[2] ;
21158
21159 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21163 }
21164 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21165 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21166 if (!SWIG_IsOK(ecode2)) {
21167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21168 }
21169 arg2 = static_cast< bool >(val2);
21170 if (arg1) (arg1)->m_leftDown = arg2;
21171
21172 resultobj = SWIG_Py_Void();
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21180 PyObject *resultobj = 0;
21181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21182 bool result;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 PyObject *swig_obj[1] ;
21186
21187 if (!args) SWIG_fail;
21188 swig_obj[0] = args;
21189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21192 }
21193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21194 result = (bool) ((arg1)->m_leftDown);
21195 {
21196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21197 }
21198 return resultobj;
21199 fail:
21200 return NULL;
21201 }
21202
21203
21204 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21205 PyObject *resultobj = 0;
21206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21207 bool arg2 ;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 bool val2 ;
21211 int ecode2 = 0 ;
21212 PyObject *swig_obj[2] ;
21213
21214 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21216 if (!SWIG_IsOK(res1)) {
21217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21218 }
21219 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21220 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21221 if (!SWIG_IsOK(ecode2)) {
21222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21223 }
21224 arg2 = static_cast< bool >(val2);
21225 if (arg1) (arg1)->m_middleDown = arg2;
21226
21227 resultobj = SWIG_Py_Void();
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21235 PyObject *resultobj = 0;
21236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21237 bool result;
21238 void *argp1 = 0 ;
21239 int res1 = 0 ;
21240 PyObject *swig_obj[1] ;
21241
21242 if (!args) SWIG_fail;
21243 swig_obj[0] = args;
21244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21245 if (!SWIG_IsOK(res1)) {
21246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21247 }
21248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21249 result = (bool) ((arg1)->m_middleDown);
21250 {
21251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21252 }
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260 PyObject *resultobj = 0;
21261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21262 bool arg2 ;
21263 void *argp1 = 0 ;
21264 int res1 = 0 ;
21265 bool val2 ;
21266 int ecode2 = 0 ;
21267 PyObject *swig_obj[2] ;
21268
21269 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21275 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21276 if (!SWIG_IsOK(ecode2)) {
21277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21278 }
21279 arg2 = static_cast< bool >(val2);
21280 if (arg1) (arg1)->m_rightDown = arg2;
21281
21282 resultobj = SWIG_Py_Void();
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21290 PyObject *resultobj = 0;
21291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21292 bool result;
21293 void *argp1 = 0 ;
21294 int res1 = 0 ;
21295 PyObject *swig_obj[1] ;
21296
21297 if (!args) SWIG_fail;
21298 swig_obj[0] = args;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 result = (bool) ((arg1)->m_rightDown);
21305 {
21306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21307 }
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21317 bool arg2 ;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 bool val2 ;
21321 int ecode2 = 0 ;
21322 PyObject *swig_obj[2] ;
21323
21324 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21326 if (!SWIG_IsOK(res1)) {
21327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21328 }
21329 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21330 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21331 if (!SWIG_IsOK(ecode2)) {
21332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21333 }
21334 arg2 = static_cast< bool >(val2);
21335 if (arg1) (arg1)->m_controlDown = arg2;
21336
21337 resultobj = SWIG_Py_Void();
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21345 PyObject *resultobj = 0;
21346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21347 bool result;
21348 void *argp1 = 0 ;
21349 int res1 = 0 ;
21350 PyObject *swig_obj[1] ;
21351
21352 if (!args) SWIG_fail;
21353 swig_obj[0] = args;
21354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21355 if (!SWIG_IsOK(res1)) {
21356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21359 result = (bool) ((arg1)->m_controlDown);
21360 {
21361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21362 }
21363 return resultobj;
21364 fail:
21365 return NULL;
21366 }
21367
21368
21369 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21370 PyObject *resultobj = 0;
21371 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21372 bool arg2 ;
21373 void *argp1 = 0 ;
21374 int res1 = 0 ;
21375 bool val2 ;
21376 int ecode2 = 0 ;
21377 PyObject *swig_obj[2] ;
21378
21379 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21381 if (!SWIG_IsOK(res1)) {
21382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21383 }
21384 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21385 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21386 if (!SWIG_IsOK(ecode2)) {
21387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21388 }
21389 arg2 = static_cast< bool >(val2);
21390 if (arg1) (arg1)->m_shiftDown = arg2;
21391
21392 resultobj = SWIG_Py_Void();
21393 return resultobj;
21394 fail:
21395 return NULL;
21396 }
21397
21398
21399 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21400 PyObject *resultobj = 0;
21401 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21402 bool result;
21403 void *argp1 = 0 ;
21404 int res1 = 0 ;
21405 PyObject *swig_obj[1] ;
21406
21407 if (!args) SWIG_fail;
21408 swig_obj[0] = args;
21409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21410 if (!SWIG_IsOK(res1)) {
21411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21412 }
21413 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21414 result = (bool) ((arg1)->m_shiftDown);
21415 {
21416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21417 }
21418 return resultobj;
21419 fail:
21420 return NULL;
21421 }
21422
21423
21424 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21425 PyObject *resultobj = 0;
21426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21427 bool arg2 ;
21428 void *argp1 = 0 ;
21429 int res1 = 0 ;
21430 bool val2 ;
21431 int ecode2 = 0 ;
21432 PyObject *swig_obj[2] ;
21433
21434 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21436 if (!SWIG_IsOK(res1)) {
21437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21438 }
21439 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21440 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21441 if (!SWIG_IsOK(ecode2)) {
21442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21443 }
21444 arg2 = static_cast< bool >(val2);
21445 if (arg1) (arg1)->m_altDown = arg2;
21446
21447 resultobj = SWIG_Py_Void();
21448 return resultobj;
21449 fail:
21450 return NULL;
21451 }
21452
21453
21454 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21455 PyObject *resultobj = 0;
21456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21457 bool result;
21458 void *argp1 = 0 ;
21459 int res1 = 0 ;
21460 PyObject *swig_obj[1] ;
21461
21462 if (!args) SWIG_fail;
21463 swig_obj[0] = args;
21464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21465 if (!SWIG_IsOK(res1)) {
21466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21467 }
21468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21469 result = (bool) ((arg1)->m_altDown);
21470 {
21471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21472 }
21473 return resultobj;
21474 fail:
21475 return NULL;
21476 }
21477
21478
21479 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21480 PyObject *resultobj = 0;
21481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21482 bool arg2 ;
21483 void *argp1 = 0 ;
21484 int res1 = 0 ;
21485 bool val2 ;
21486 int ecode2 = 0 ;
21487 PyObject *swig_obj[2] ;
21488
21489 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21491 if (!SWIG_IsOK(res1)) {
21492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21493 }
21494 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21495 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21496 if (!SWIG_IsOK(ecode2)) {
21497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21498 }
21499 arg2 = static_cast< bool >(val2);
21500 if (arg1) (arg1)->m_metaDown = arg2;
21501
21502 resultobj = SWIG_Py_Void();
21503 return resultobj;
21504 fail:
21505 return NULL;
21506 }
21507
21508
21509 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21510 PyObject *resultobj = 0;
21511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21512 bool result;
21513 void *argp1 = 0 ;
21514 int res1 = 0 ;
21515 PyObject *swig_obj[1] ;
21516
21517 if (!args) SWIG_fail;
21518 swig_obj[0] = args;
21519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21520 if (!SWIG_IsOK(res1)) {
21521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21522 }
21523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21524 result = (bool) ((arg1)->m_metaDown);
21525 {
21526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21527 }
21528 return resultobj;
21529 fail:
21530 return NULL;
21531 }
21532
21533
21534 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21535 PyObject *resultobj = 0;
21536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21537 int arg2 ;
21538 void *argp1 = 0 ;
21539 int res1 = 0 ;
21540 int val2 ;
21541 int ecode2 = 0 ;
21542 PyObject *swig_obj[2] ;
21543
21544 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21546 if (!SWIG_IsOK(res1)) {
21547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21548 }
21549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21550 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21551 if (!SWIG_IsOK(ecode2)) {
21552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21553 }
21554 arg2 = static_cast< int >(val2);
21555 if (arg1) (arg1)->m_wheelRotation = arg2;
21556
21557 resultobj = SWIG_Py_Void();
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21565 PyObject *resultobj = 0;
21566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21567 int result;
21568 void *argp1 = 0 ;
21569 int res1 = 0 ;
21570 PyObject *swig_obj[1] ;
21571
21572 if (!args) SWIG_fail;
21573 swig_obj[0] = args;
21574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21575 if (!SWIG_IsOK(res1)) {
21576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21577 }
21578 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21579 result = (int) ((arg1)->m_wheelRotation);
21580 resultobj = SWIG_From_int(static_cast< int >(result));
21581 return resultobj;
21582 fail:
21583 return NULL;
21584 }
21585
21586
21587 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21588 PyObject *resultobj = 0;
21589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21590 int arg2 ;
21591 void *argp1 = 0 ;
21592 int res1 = 0 ;
21593 int val2 ;
21594 int ecode2 = 0 ;
21595 PyObject *swig_obj[2] ;
21596
21597 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21604 if (!SWIG_IsOK(ecode2)) {
21605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21606 }
21607 arg2 = static_cast< int >(val2);
21608 if (arg1) (arg1)->m_wheelDelta = arg2;
21609
21610 resultobj = SWIG_Py_Void();
21611 return resultobj;
21612 fail:
21613 return NULL;
21614 }
21615
21616
21617 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21618 PyObject *resultobj = 0;
21619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21620 int result;
21621 void *argp1 = 0 ;
21622 int res1 = 0 ;
21623 PyObject *swig_obj[1] ;
21624
21625 if (!args) SWIG_fail;
21626 swig_obj[0] = args;
21627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21628 if (!SWIG_IsOK(res1)) {
21629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21630 }
21631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21632 result = (int) ((arg1)->m_wheelDelta);
21633 resultobj = SWIG_From_int(static_cast< int >(result));
21634 return resultobj;
21635 fail:
21636 return NULL;
21637 }
21638
21639
21640 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 PyObject *resultobj = 0;
21642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21643 int arg2 ;
21644 void *argp1 = 0 ;
21645 int res1 = 0 ;
21646 int val2 ;
21647 int ecode2 = 0 ;
21648 PyObject *swig_obj[2] ;
21649
21650 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21652 if (!SWIG_IsOK(res1)) {
21653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21654 }
21655 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21656 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21657 if (!SWIG_IsOK(ecode2)) {
21658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21659 }
21660 arg2 = static_cast< int >(val2);
21661 if (arg1) (arg1)->m_linesPerAction = arg2;
21662
21663 resultobj = SWIG_Py_Void();
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21673 int result;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 PyObject *swig_obj[1] ;
21677
21678 if (!args) SWIG_fail;
21679 swig_obj[0] = args;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21683 }
21684 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21685 result = (int) ((arg1)->m_linesPerAction);
21686 resultobj = SWIG_From_int(static_cast< int >(result));
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21694 PyObject *obj;
21695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21696 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21697 return SWIG_Py_Void();
21698 }
21699
21700 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21701 return SWIG_Python_InitShadowInstance(args);
21702 }
21703
21704 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj = 0;
21706 int arg1 = (int) 0 ;
21707 int arg2 = (int) 0 ;
21708 wxSetCursorEvent *result = 0 ;
21709 int val1 ;
21710 int ecode1 = 0 ;
21711 int val2 ;
21712 int ecode2 = 0 ;
21713 PyObject * obj0 = 0 ;
21714 PyObject * obj1 = 0 ;
21715 char * kwnames[] = {
21716 (char *) "x",(char *) "y", NULL
21717 };
21718
21719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21720 if (obj0) {
21721 ecode1 = SWIG_AsVal_int(obj0, &val1);
21722 if (!SWIG_IsOK(ecode1)) {
21723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21724 }
21725 arg1 = static_cast< int >(val1);
21726 }
21727 if (obj1) {
21728 ecode2 = SWIG_AsVal_int(obj1, &val2);
21729 if (!SWIG_IsOK(ecode2)) {
21730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21731 }
21732 arg2 = static_cast< int >(val2);
21733 }
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21741 return resultobj;
21742 fail:
21743 return NULL;
21744 }
21745
21746
21747 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21748 PyObject *resultobj = 0;
21749 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21750 int result;
21751 void *argp1 = 0 ;
21752 int res1 = 0 ;
21753 PyObject *swig_obj[1] ;
21754
21755 if (!args) SWIG_fail;
21756 swig_obj[0] = args;
21757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21758 if (!SWIG_IsOK(res1)) {
21759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21760 }
21761 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21762 {
21763 PyThreadState* __tstate = wxPyBeginAllowThreads();
21764 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21765 wxPyEndAllowThreads(__tstate);
21766 if (PyErr_Occurred()) SWIG_fail;
21767 }
21768 resultobj = SWIG_From_int(static_cast< int >(result));
21769 return resultobj;
21770 fail:
21771 return NULL;
21772 }
21773
21774
21775 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21776 PyObject *resultobj = 0;
21777 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21778 int result;
21779 void *argp1 = 0 ;
21780 int res1 = 0 ;
21781 PyObject *swig_obj[1] ;
21782
21783 if (!args) SWIG_fail;
21784 swig_obj[0] = args;
21785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21786 if (!SWIG_IsOK(res1)) {
21787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21788 }
21789 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 resultobj = SWIG_From_int(static_cast< int >(result));
21797 return resultobj;
21798 fail:
21799 return NULL;
21800 }
21801
21802
21803 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21804 PyObject *resultobj = 0;
21805 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21806 wxCursor *arg2 = 0 ;
21807 void *argp1 = 0 ;
21808 int res1 = 0 ;
21809 void *argp2 = 0 ;
21810 int res2 = 0 ;
21811 PyObject * obj0 = 0 ;
21812 PyObject * obj1 = 0 ;
21813 char * kwnames[] = {
21814 (char *) "self",(char *) "cursor", NULL
21815 };
21816
21817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21819 if (!SWIG_IsOK(res1)) {
21820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21821 }
21822 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21824 if (!SWIG_IsOK(res2)) {
21825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21826 }
21827 if (!argp2) {
21828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21829 }
21830 arg2 = reinterpret_cast< wxCursor * >(argp2);
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetCursor((wxCursor const &)*arg2);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_Py_Void();
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21845 PyObject *resultobj = 0;
21846 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21847 wxCursor *result = 0 ;
21848 void *argp1 = 0 ;
21849 int res1 = 0 ;
21850 PyObject *swig_obj[1] ;
21851
21852 if (!args) SWIG_fail;
21853 swig_obj[0] = args;
21854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21855 if (!SWIG_IsOK(res1)) {
21856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21857 }
21858 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21859 {
21860 PyThreadState* __tstate = wxPyBeginAllowThreads();
21861 {
21862 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21863 result = (wxCursor *) &_result_ref;
21864 }
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 {
21869 wxCursor* resultptr = new wxCursor(*result);
21870 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21871 }
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21879 PyObject *resultobj = 0;
21880 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21881 bool result;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 PyObject *swig_obj[1] ;
21885
21886 if (!args) SWIG_fail;
21887 swig_obj[0] = args;
21888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21889 if (!SWIG_IsOK(res1)) {
21890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21891 }
21892 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21893 {
21894 PyThreadState* __tstate = wxPyBeginAllowThreads();
21895 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21909 PyObject *obj;
21910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21911 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21912 return SWIG_Py_Void();
21913 }
21914
21915 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 return SWIG_Python_InitShadowInstance(args);
21917 }
21918
21919 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21920 PyObject *resultobj = 0;
21921 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21922 wxKeyEvent *result = 0 ;
21923 int val1 ;
21924 int ecode1 = 0 ;
21925 PyObject * obj0 = 0 ;
21926 char * kwnames[] = {
21927 (char *) "eventType", NULL
21928 };
21929
21930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21931 if (obj0) {
21932 ecode1 = SWIG_AsVal_int(obj0, &val1);
21933 if (!SWIG_IsOK(ecode1)) {
21934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21935 }
21936 arg1 = static_cast< wxEventType >(val1);
21937 }
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21945 return resultobj;
21946 fail:
21947 return NULL;
21948 }
21949
21950
21951 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21952 PyObject *resultobj = 0;
21953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21954 int result;
21955 void *argp1 = 0 ;
21956 int res1 = 0 ;
21957 PyObject *swig_obj[1] ;
21958
21959 if (!args) SWIG_fail;
21960 swig_obj[0] = args;
21961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21964 }
21965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21966 {
21967 PyThreadState* __tstate = wxPyBeginAllowThreads();
21968 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21969 wxPyEndAllowThreads(__tstate);
21970 if (PyErr_Occurred()) SWIG_fail;
21971 }
21972 resultobj = SWIG_From_int(static_cast< int >(result));
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21980 PyObject *resultobj = 0;
21981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21982 bool result;
21983 void *argp1 = 0 ;
21984 int res1 = 0 ;
21985 PyObject *swig_obj[1] ;
21986
21987 if (!args) SWIG_fail;
21988 swig_obj[0] = args;
21989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21990 if (!SWIG_IsOK(res1)) {
21991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21992 }
21993 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21994 {
21995 PyThreadState* __tstate = wxPyBeginAllowThreads();
21996 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21997 wxPyEndAllowThreads(__tstate);
21998 if (PyErr_Occurred()) SWIG_fail;
21999 }
22000 {
22001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22002 }
22003 return resultobj;
22004 fail:
22005 return NULL;
22006 }
22007
22008
22009 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22010 PyObject *resultobj = 0;
22011 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22012 bool result;
22013 void *argp1 = 0 ;
22014 int res1 = 0 ;
22015 PyObject *swig_obj[1] ;
22016
22017 if (!args) SWIG_fail;
22018 swig_obj[0] = args;
22019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22020 if (!SWIG_IsOK(res1)) {
22021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22022 }
22023 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22024 {
22025 PyThreadState* __tstate = wxPyBeginAllowThreads();
22026 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22027 wxPyEndAllowThreads(__tstate);
22028 if (PyErr_Occurred()) SWIG_fail;
22029 }
22030 {
22031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22032 }
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22042 bool result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22052 }
22053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 {
22061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22062 }
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22072 bool result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 {
22091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22092 }
22093 return resultobj;
22094 fail:
22095 return NULL;
22096 }
22097
22098
22099 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22100 PyObject *resultobj = 0;
22101 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22102 bool result;
22103 void *argp1 = 0 ;
22104 int res1 = 0 ;
22105 PyObject *swig_obj[1] ;
22106
22107 if (!args) SWIG_fail;
22108 swig_obj[0] = args;
22109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22110 if (!SWIG_IsOK(res1)) {
22111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22112 }
22113 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22114 {
22115 PyThreadState* __tstate = wxPyBeginAllowThreads();
22116 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22117 wxPyEndAllowThreads(__tstate);
22118 if (PyErr_Occurred()) SWIG_fail;
22119 }
22120 {
22121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22122 }
22123 return resultobj;
22124 fail:
22125 return NULL;
22126 }
22127
22128
22129 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22130 PyObject *resultobj = 0;
22131 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22132 bool result;
22133 void *argp1 = 0 ;
22134 int res1 = 0 ;
22135 PyObject *swig_obj[1] ;
22136
22137 if (!args) SWIG_fail;
22138 swig_obj[0] = args;
22139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22140 if (!SWIG_IsOK(res1)) {
22141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22142 }
22143 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22144 {
22145 PyThreadState* __tstate = wxPyBeginAllowThreads();
22146 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22147 wxPyEndAllowThreads(__tstate);
22148 if (PyErr_Occurred()) SWIG_fail;
22149 }
22150 {
22151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22152 }
22153 return resultobj;
22154 fail:
22155 return NULL;
22156 }
22157
22158
22159 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22160 PyObject *resultobj = 0;
22161 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22162 int result;
22163 void *argp1 = 0 ;
22164 int res1 = 0 ;
22165 PyObject *swig_obj[1] ;
22166
22167 if (!args) SWIG_fail;
22168 swig_obj[0] = args;
22169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22170 if (!SWIG_IsOK(res1)) {
22171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22172 }
22173 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 resultobj = SWIG_From_int(static_cast< int >(result));
22181 return resultobj;
22182 fail:
22183 return NULL;
22184 }
22185
22186
22187 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22188 PyObject *resultobj = 0;
22189 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22190 int result;
22191 void *argp1 = 0 ;
22192 int res1 = 0 ;
22193 PyObject *swig_obj[1] ;
22194
22195 if (!args) SWIG_fail;
22196 swig_obj[0] = args;
22197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22198 if (!SWIG_IsOK(res1)) {
22199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22200 }
22201 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22205 wxPyEndAllowThreads(__tstate);
22206 if (PyErr_Occurred()) SWIG_fail;
22207 }
22208 resultobj = SWIG_From_int(static_cast< int >(result));
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj = 0;
22217 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22218 int arg2 ;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 int val2 ;
22222 int ecode2 = 0 ;
22223 PyObject * obj0 = 0 ;
22224 PyObject * obj1 = 0 ;
22225 char * kwnames[] = {
22226 (char *) "self",(char *) "uniChar", NULL
22227 };
22228
22229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22231 if (!SWIG_IsOK(res1)) {
22232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22233 }
22234 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22235 ecode2 = SWIG_AsVal_int(obj1, &val2);
22236 if (!SWIG_IsOK(ecode2)) {
22237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22238 }
22239 arg2 = static_cast< int >(val2);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_Py_Void();
22247 return resultobj;
22248 fail:
22249 return NULL;
22250 }
22251
22252
22253 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22254 PyObject *resultobj = 0;
22255 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22256 unsigned int result;
22257 void *argp1 = 0 ;
22258 int res1 = 0 ;
22259 PyObject *swig_obj[1] ;
22260
22261 if (!args) SWIG_fail;
22262 swig_obj[0] = args;
22263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22264 if (!SWIG_IsOK(res1)) {
22265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22266 }
22267 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22268 {
22269 PyThreadState* __tstate = wxPyBeginAllowThreads();
22270 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 unsigned int result;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 PyObject *swig_obj[1] ;
22288
22289 if (!args) SWIG_fail;
22290 swig_obj[0] = args;
22291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22292 if (!SWIG_IsOK(res1)) {
22293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22294 }
22295 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22299 wxPyEndAllowThreads(__tstate);
22300 if (PyErr_Occurred()) SWIG_fail;
22301 }
22302 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22303 return resultobj;
22304 fail:
22305 return NULL;
22306 }
22307
22308
22309 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 PyObject *resultobj = 0;
22311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22312 wxPoint result;
22313 void *argp1 = 0 ;
22314 int res1 = 0 ;
22315 PyObject *swig_obj[1] ;
22316
22317 if (!args) SWIG_fail;
22318 swig_obj[0] = args;
22319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22320 if (!SWIG_IsOK(res1)) {
22321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22322 }
22323 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 result = (arg1)->GetPosition();
22327 wxPyEndAllowThreads(__tstate);
22328 if (PyErr_Occurred()) SWIG_fail;
22329 }
22330 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22340 long *arg2 = (long *) 0 ;
22341 long *arg3 = (long *) 0 ;
22342 void *argp1 = 0 ;
22343 int res1 = 0 ;
22344 long temp2 ;
22345 int res2 = SWIG_TMPOBJ ;
22346 long temp3 ;
22347 int res3 = SWIG_TMPOBJ ;
22348 PyObject *swig_obj[1] ;
22349
22350 arg2 = &temp2;
22351 arg3 = &temp3;
22352 if (!args) SWIG_fail;
22353 swig_obj[0] = args;
22354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22355 if (!SWIG_IsOK(res1)) {
22356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22357 }
22358 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22359 {
22360 PyThreadState* __tstate = wxPyBeginAllowThreads();
22361 (arg1)->GetPosition(arg2,arg3);
22362 wxPyEndAllowThreads(__tstate);
22363 if (PyErr_Occurred()) SWIG_fail;
22364 }
22365 resultobj = SWIG_Py_Void();
22366 if (SWIG_IsTmpObj(res2)) {
22367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22368 } else {
22369 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22371 }
22372 if (SWIG_IsTmpObj(res3)) {
22373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22374 } else {
22375 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22377 }
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22385 PyObject *resultobj = 0;
22386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22387 int result;
22388 void *argp1 = 0 ;
22389 int res1 = 0 ;
22390 PyObject *swig_obj[1] ;
22391
22392 if (!args) SWIG_fail;
22393 swig_obj[0] = args;
22394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22395 if (!SWIG_IsOK(res1)) {
22396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22397 }
22398 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = (int)((wxKeyEvent const *)arg1)->GetX();
22402 wxPyEndAllowThreads(__tstate);
22403 if (PyErr_Occurred()) SWIG_fail;
22404 }
22405 resultobj = SWIG_From_int(static_cast< int >(result));
22406 return resultobj;
22407 fail:
22408 return NULL;
22409 }
22410
22411
22412 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22413 PyObject *resultobj = 0;
22414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22415 int result;
22416 void *argp1 = 0 ;
22417 int res1 = 0 ;
22418 PyObject *swig_obj[1] ;
22419
22420 if (!args) SWIG_fail;
22421 swig_obj[0] = args;
22422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22423 if (!SWIG_IsOK(res1)) {
22424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22425 }
22426 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22427 {
22428 PyThreadState* __tstate = wxPyBeginAllowThreads();
22429 result = (int)((wxKeyEvent const *)arg1)->GetY();
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 resultobj = SWIG_From_int(static_cast< int >(result));
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22441 PyObject *resultobj = 0;
22442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22443 int arg2 ;
22444 void *argp1 = 0 ;
22445 int res1 = 0 ;
22446 int val2 ;
22447 int ecode2 = 0 ;
22448 PyObject *swig_obj[2] ;
22449
22450 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22454 }
22455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22456 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22457 if (!SWIG_IsOK(ecode2)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22459 }
22460 arg2 = static_cast< int >(val2);
22461 if (arg1) (arg1)->m_x = arg2;
22462
22463 resultobj = SWIG_Py_Void();
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22471 PyObject *resultobj = 0;
22472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22473 int result;
22474 void *argp1 = 0 ;
22475 int res1 = 0 ;
22476 PyObject *swig_obj[1] ;
22477
22478 if (!args) SWIG_fail;
22479 swig_obj[0] = args;
22480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22481 if (!SWIG_IsOK(res1)) {
22482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22483 }
22484 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22485 result = (int) ((arg1)->m_x);
22486 resultobj = SWIG_From_int(static_cast< int >(result));
22487 return resultobj;
22488 fail:
22489 return NULL;
22490 }
22491
22492
22493 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22494 PyObject *resultobj = 0;
22495 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22496 int arg2 ;
22497 void *argp1 = 0 ;
22498 int res1 = 0 ;
22499 int val2 ;
22500 int ecode2 = 0 ;
22501 PyObject *swig_obj[2] ;
22502
22503 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22507 }
22508 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22509 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22510 if (!SWIG_IsOK(ecode2)) {
22511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22512 }
22513 arg2 = static_cast< int >(val2);
22514 if (arg1) (arg1)->m_y = arg2;
22515
22516 resultobj = SWIG_Py_Void();
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22524 PyObject *resultobj = 0;
22525 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22526 int result;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 PyObject *swig_obj[1] ;
22530
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_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22536 }
22537 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22538 result = (int) ((arg1)->m_y);
22539 resultobj = SWIG_From_int(static_cast< int >(result));
22540 return resultobj;
22541 fail:
22542 return NULL;
22543 }
22544
22545
22546 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22547 PyObject *resultobj = 0;
22548 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22549 long arg2 ;
22550 void *argp1 = 0 ;
22551 int res1 = 0 ;
22552 long val2 ;
22553 int ecode2 = 0 ;
22554 PyObject *swig_obj[2] ;
22555
22556 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22558 if (!SWIG_IsOK(res1)) {
22559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22560 }
22561 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22562 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22563 if (!SWIG_IsOK(ecode2)) {
22564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22565 }
22566 arg2 = static_cast< long >(val2);
22567 if (arg1) (arg1)->m_keyCode = arg2;
22568
22569 resultobj = SWIG_Py_Void();
22570 return resultobj;
22571 fail:
22572 return NULL;
22573 }
22574
22575
22576 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22577 PyObject *resultobj = 0;
22578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22579 long result;
22580 void *argp1 = 0 ;
22581 int res1 = 0 ;
22582 PyObject *swig_obj[1] ;
22583
22584 if (!args) SWIG_fail;
22585 swig_obj[0] = args;
22586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22587 if (!SWIG_IsOK(res1)) {
22588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22589 }
22590 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22591 result = (long) ((arg1)->m_keyCode);
22592 resultobj = SWIG_From_long(static_cast< long >(result));
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22600 PyObject *resultobj = 0;
22601 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22602 bool arg2 ;
22603 void *argp1 = 0 ;
22604 int res1 = 0 ;
22605 bool val2 ;
22606 int ecode2 = 0 ;
22607 PyObject *swig_obj[2] ;
22608
22609 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22611 if (!SWIG_IsOK(res1)) {
22612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22613 }
22614 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22615 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22616 if (!SWIG_IsOK(ecode2)) {
22617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22618 }
22619 arg2 = static_cast< bool >(val2);
22620 if (arg1) (arg1)->m_controlDown = arg2;
22621
22622 resultobj = SWIG_Py_Void();
22623 return resultobj;
22624 fail:
22625 return NULL;
22626 }
22627
22628
22629 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22630 PyObject *resultobj = 0;
22631 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22632 bool result;
22633 void *argp1 = 0 ;
22634 int res1 = 0 ;
22635 PyObject *swig_obj[1] ;
22636
22637 if (!args) SWIG_fail;
22638 swig_obj[0] = args;
22639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22640 if (!SWIG_IsOK(res1)) {
22641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22642 }
22643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22644 result = (bool) ((arg1)->m_controlDown);
22645 {
22646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22647 }
22648 return resultobj;
22649 fail:
22650 return NULL;
22651 }
22652
22653
22654 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22655 PyObject *resultobj = 0;
22656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22657 bool arg2 ;
22658 void *argp1 = 0 ;
22659 int res1 = 0 ;
22660 bool val2 ;
22661 int ecode2 = 0 ;
22662 PyObject *swig_obj[2] ;
22663
22664 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22666 if (!SWIG_IsOK(res1)) {
22667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22668 }
22669 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22670 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22671 if (!SWIG_IsOK(ecode2)) {
22672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22673 }
22674 arg2 = static_cast< bool >(val2);
22675 if (arg1) (arg1)->m_shiftDown = arg2;
22676
22677 resultobj = SWIG_Py_Void();
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22685 PyObject *resultobj = 0;
22686 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22687 bool result;
22688 void *argp1 = 0 ;
22689 int res1 = 0 ;
22690 PyObject *swig_obj[1] ;
22691
22692 if (!args) SWIG_fail;
22693 swig_obj[0] = args;
22694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22695 if (!SWIG_IsOK(res1)) {
22696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22697 }
22698 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22699 result = (bool) ((arg1)->m_shiftDown);
22700 {
22701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22702 }
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22712 bool arg2 ;
22713 void *argp1 = 0 ;
22714 int res1 = 0 ;
22715 bool val2 ;
22716 int ecode2 = 0 ;
22717 PyObject *swig_obj[2] ;
22718
22719 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22723 }
22724 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22725 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22726 if (!SWIG_IsOK(ecode2)) {
22727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22728 }
22729 arg2 = static_cast< bool >(val2);
22730 if (arg1) (arg1)->m_altDown = arg2;
22731
22732 resultobj = SWIG_Py_Void();
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 PyObject *resultobj = 0;
22741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22742 bool result;
22743 void *argp1 = 0 ;
22744 int res1 = 0 ;
22745 PyObject *swig_obj[1] ;
22746
22747 if (!args) SWIG_fail;
22748 swig_obj[0] = args;
22749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22750 if (!SWIG_IsOK(res1)) {
22751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22752 }
22753 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22754 result = (bool) ((arg1)->m_altDown);
22755 {
22756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22757 }
22758 return resultobj;
22759 fail:
22760 return NULL;
22761 }
22762
22763
22764 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22765 PyObject *resultobj = 0;
22766 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22767 bool arg2 ;
22768 void *argp1 = 0 ;
22769 int res1 = 0 ;
22770 bool val2 ;
22771 int ecode2 = 0 ;
22772 PyObject *swig_obj[2] ;
22773
22774 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22776 if (!SWIG_IsOK(res1)) {
22777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22778 }
22779 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22780 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22781 if (!SWIG_IsOK(ecode2)) {
22782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22783 }
22784 arg2 = static_cast< bool >(val2);
22785 if (arg1) (arg1)->m_metaDown = arg2;
22786
22787 resultobj = SWIG_Py_Void();
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22795 PyObject *resultobj = 0;
22796 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22797 bool result;
22798 void *argp1 = 0 ;
22799 int res1 = 0 ;
22800 PyObject *swig_obj[1] ;
22801
22802 if (!args) SWIG_fail;
22803 swig_obj[0] = args;
22804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22805 if (!SWIG_IsOK(res1)) {
22806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22807 }
22808 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22809 result = (bool) ((arg1)->m_metaDown);
22810 {
22811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22812 }
22813 return resultobj;
22814 fail:
22815 return NULL;
22816 }
22817
22818
22819 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22820 PyObject *resultobj = 0;
22821 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22822 bool arg2 ;
22823 void *argp1 = 0 ;
22824 int res1 = 0 ;
22825 bool val2 ;
22826 int ecode2 = 0 ;
22827 PyObject *swig_obj[2] ;
22828
22829 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22831 if (!SWIG_IsOK(res1)) {
22832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22833 }
22834 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22835 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22836 if (!SWIG_IsOK(ecode2)) {
22837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22838 }
22839 arg2 = static_cast< bool >(val2);
22840 if (arg1) (arg1)->m_scanCode = arg2;
22841
22842 resultobj = SWIG_Py_Void();
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22850 PyObject *resultobj = 0;
22851 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22852 bool result;
22853 void *argp1 = 0 ;
22854 int res1 = 0 ;
22855 PyObject *swig_obj[1] ;
22856
22857 if (!args) SWIG_fail;
22858 swig_obj[0] = args;
22859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22860 if (!SWIG_IsOK(res1)) {
22861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22862 }
22863 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22864 result = (bool) ((arg1)->m_scanCode);
22865 {
22866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22867 }
22868 return resultobj;
22869 fail:
22870 return NULL;
22871 }
22872
22873
22874 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22875 PyObject *resultobj = 0;
22876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22877 unsigned int arg2 ;
22878 void *argp1 = 0 ;
22879 int res1 = 0 ;
22880 unsigned int val2 ;
22881 int ecode2 = 0 ;
22882 PyObject *swig_obj[2] ;
22883
22884 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22888 }
22889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22890 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22893 }
22894 arg2 = static_cast< unsigned int >(val2);
22895 if (arg1) (arg1)->m_rawCode = arg2;
22896
22897 resultobj = SWIG_Py_Void();
22898 return resultobj;
22899 fail:
22900 return NULL;
22901 }
22902
22903
22904 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22905 PyObject *resultobj = 0;
22906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22907 unsigned int result;
22908 void *argp1 = 0 ;
22909 int res1 = 0 ;
22910 PyObject *swig_obj[1] ;
22911
22912 if (!args) SWIG_fail;
22913 swig_obj[0] = args;
22914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22917 }
22918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22919 result = (unsigned int) ((arg1)->m_rawCode);
22920 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 PyObject *resultobj = 0;
22929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22930 unsigned int arg2 ;
22931 void *argp1 = 0 ;
22932 int res1 = 0 ;
22933 unsigned int val2 ;
22934 int ecode2 = 0 ;
22935 PyObject *swig_obj[2] ;
22936
22937 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22941 }
22942 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22943 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22944 if (!SWIG_IsOK(ecode2)) {
22945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22946 }
22947 arg2 = static_cast< unsigned int >(val2);
22948 if (arg1) (arg1)->m_rawFlags = arg2;
22949
22950 resultobj = SWIG_Py_Void();
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22958 PyObject *resultobj = 0;
22959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22960 unsigned int result;
22961 void *argp1 = 0 ;
22962 int res1 = 0 ;
22963 PyObject *swig_obj[1] ;
22964
22965 if (!args) SWIG_fail;
22966 swig_obj[0] = args;
22967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22968 if (!SWIG_IsOK(res1)) {
22969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22970 }
22971 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22972 result = (unsigned int) ((arg1)->m_rawFlags);
22973 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22974 return resultobj;
22975 fail:
22976 return NULL;
22977 }
22978
22979
22980 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22981 PyObject *obj;
22982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22983 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22984 return SWIG_Py_Void();
22985 }
22986
22987 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22988 return SWIG_Python_InitShadowInstance(args);
22989 }
22990
22991 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = 0;
22993 wxSize const &arg1_defvalue = wxDefaultSize ;
22994 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22995 int arg2 = (int) 0 ;
22996 wxSizeEvent *result = 0 ;
22997 wxSize temp1 ;
22998 int val2 ;
22999 int ecode2 = 0 ;
23000 PyObject * obj0 = 0 ;
23001 PyObject * obj1 = 0 ;
23002 char * kwnames[] = {
23003 (char *) "sz",(char *) "winid", NULL
23004 };
23005
23006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23007 if (obj0) {
23008 {
23009 arg1 = &temp1;
23010 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23011 }
23012 }
23013 if (obj1) {
23014 ecode2 = SWIG_AsVal_int(obj1, &val2);
23015 if (!SWIG_IsOK(ecode2)) {
23016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23017 }
23018 arg2 = static_cast< int >(val2);
23019 }
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23034 PyObject *resultobj = 0;
23035 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23036 wxSize result;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 PyObject *swig_obj[1] ;
23040
23041 if (!args) SWIG_fail;
23042 swig_obj[0] = args;
23043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23046 }
23047 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23048 {
23049 PyThreadState* __tstate = wxPyBeginAllowThreads();
23050 result = ((wxSizeEvent const *)arg1)->GetSize();
23051 wxPyEndAllowThreads(__tstate);
23052 if (PyErr_Occurred()) SWIG_fail;
23053 }
23054 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23062 PyObject *resultobj = 0;
23063 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23064 wxRect result;
23065 void *argp1 = 0 ;
23066 int res1 = 0 ;
23067 PyObject *swig_obj[1] ;
23068
23069 if (!args) SWIG_fail;
23070 swig_obj[0] = args;
23071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23072 if (!SWIG_IsOK(res1)) {
23073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23074 }
23075 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23076 {
23077 PyThreadState* __tstate = wxPyBeginAllowThreads();
23078 result = ((wxSizeEvent const *)arg1)->GetRect();
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23083 return resultobj;
23084 fail:
23085 return NULL;
23086 }
23087
23088
23089 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = 0;
23091 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23092 wxRect arg2 ;
23093 void *argp1 = 0 ;
23094 int res1 = 0 ;
23095 void *argp2 ;
23096 int res2 = 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char * kwnames[] = {
23100 (char *) "self",(char *) "rect", NULL
23101 };
23102
23103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23107 }
23108 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23109 {
23110 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23111 if (!SWIG_IsOK(res2)) {
23112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23113 }
23114 if (!argp2) {
23115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23116 } else {
23117 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23118 arg2 = *temp;
23119 if (SWIG_IsNewObj(res2)) delete temp;
23120 }
23121 }
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 (arg1)->SetRect(arg2);
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 resultobj = SWIG_Py_Void();
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23136 PyObject *resultobj = 0;
23137 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23138 wxSize arg2 ;
23139 void *argp1 = 0 ;
23140 int res1 = 0 ;
23141 void *argp2 ;
23142 int res2 = 0 ;
23143 PyObject * obj0 = 0 ;
23144 PyObject * obj1 = 0 ;
23145 char * kwnames[] = {
23146 (char *) "self",(char *) "size", NULL
23147 };
23148
23149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23151 if (!SWIG_IsOK(res1)) {
23152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23153 }
23154 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23155 {
23156 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23157 if (!SWIG_IsOK(res2)) {
23158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23159 }
23160 if (!argp2) {
23161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23162 } else {
23163 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23164 arg2 = *temp;
23165 if (SWIG_IsNewObj(res2)) delete temp;
23166 }
23167 }
23168 {
23169 PyThreadState* __tstate = wxPyBeginAllowThreads();
23170 wxSizeEvent_SetSize(arg1,arg2);
23171 wxPyEndAllowThreads(__tstate);
23172 if (PyErr_Occurred()) SWIG_fail;
23173 }
23174 resultobj = SWIG_Py_Void();
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23182 PyObject *resultobj = 0;
23183 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23184 wxSize *arg2 = (wxSize *) 0 ;
23185 void *argp1 = 0 ;
23186 int res1 = 0 ;
23187 void *argp2 = 0 ;
23188 int res2 = 0 ;
23189 PyObject *swig_obj[2] ;
23190
23191 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23193 if (!SWIG_IsOK(res1)) {
23194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23195 }
23196 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23197 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23198 if (!SWIG_IsOK(res2)) {
23199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23200 }
23201 arg2 = reinterpret_cast< wxSize * >(argp2);
23202 if (arg1) (arg1)->m_size = *arg2;
23203
23204 resultobj = SWIG_Py_Void();
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23212 PyObject *resultobj = 0;
23213 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23214 wxSize *result = 0 ;
23215 void *argp1 = 0 ;
23216 int res1 = 0 ;
23217 PyObject *swig_obj[1] ;
23218
23219 if (!args) SWIG_fail;
23220 swig_obj[0] = args;
23221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23222 if (!SWIG_IsOK(res1)) {
23223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23224 }
23225 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23226 result = (wxSize *)& ((arg1)->m_size);
23227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23228 return resultobj;
23229 fail:
23230 return NULL;
23231 }
23232
23233
23234 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23235 PyObject *resultobj = 0;
23236 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23237 wxRect *arg2 = (wxRect *) 0 ;
23238 void *argp1 = 0 ;
23239 int res1 = 0 ;
23240 void *argp2 = 0 ;
23241 int res2 = 0 ;
23242 PyObject *swig_obj[2] ;
23243
23244 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23246 if (!SWIG_IsOK(res1)) {
23247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23248 }
23249 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23250 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23251 if (!SWIG_IsOK(res2)) {
23252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23253 }
23254 arg2 = reinterpret_cast< wxRect * >(argp2);
23255 if (arg1) (arg1)->m_rect = *arg2;
23256
23257 resultobj = SWIG_Py_Void();
23258 return resultobj;
23259 fail:
23260 return NULL;
23261 }
23262
23263
23264 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23265 PyObject *resultobj = 0;
23266 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23267 wxRect *result = 0 ;
23268 void *argp1 = 0 ;
23269 int res1 = 0 ;
23270 PyObject *swig_obj[1] ;
23271
23272 if (!args) SWIG_fail;
23273 swig_obj[0] = args;
23274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23275 if (!SWIG_IsOK(res1)) {
23276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23277 }
23278 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23279 result = (wxRect *)& ((arg1)->m_rect);
23280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23288 PyObject *obj;
23289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23290 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23291 return SWIG_Py_Void();
23292 }
23293
23294 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23295 return SWIG_Python_InitShadowInstance(args);
23296 }
23297
23298 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23299 PyObject *resultobj = 0;
23300 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23301 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23302 int arg2 = (int) 0 ;
23303 wxMoveEvent *result = 0 ;
23304 wxPoint temp1 ;
23305 int val2 ;
23306 int ecode2 = 0 ;
23307 PyObject * obj0 = 0 ;
23308 PyObject * obj1 = 0 ;
23309 char * kwnames[] = {
23310 (char *) "pos",(char *) "winid", NULL
23311 };
23312
23313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23314 if (obj0) {
23315 {
23316 arg1 = &temp1;
23317 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23318 }
23319 }
23320 if (obj1) {
23321 ecode2 = SWIG_AsVal_int(obj1, &val2);
23322 if (!SWIG_IsOK(ecode2)) {
23323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23324 }
23325 arg2 = static_cast< int >(val2);
23326 }
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23330 wxPyEndAllowThreads(__tstate);
23331 if (PyErr_Occurred()) SWIG_fail;
23332 }
23333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23334 return resultobj;
23335 fail:
23336 return NULL;
23337 }
23338
23339
23340 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 PyObject *resultobj = 0;
23342 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23343 wxPoint result;
23344 void *argp1 = 0 ;
23345 int res1 = 0 ;
23346 PyObject *swig_obj[1] ;
23347
23348 if (!args) SWIG_fail;
23349 swig_obj[0] = args;
23350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23351 if (!SWIG_IsOK(res1)) {
23352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23353 }
23354 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = ((wxMoveEvent const *)arg1)->GetPosition();
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23369 PyObject *resultobj = 0;
23370 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23371 wxRect result;
23372 void *argp1 = 0 ;
23373 int res1 = 0 ;
23374 PyObject *swig_obj[1] ;
23375
23376 if (!args) SWIG_fail;
23377 swig_obj[0] = args;
23378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23379 if (!SWIG_IsOK(res1)) {
23380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23381 }
23382 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = ((wxMoveEvent const *)arg1)->GetRect();
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23397 PyObject *resultobj = 0;
23398 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23399 wxRect *arg2 = 0 ;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 wxRect temp2 ;
23403 PyObject * obj0 = 0 ;
23404 PyObject * obj1 = 0 ;
23405 char * kwnames[] = {
23406 (char *) "self",(char *) "rect", NULL
23407 };
23408
23409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23411 if (!SWIG_IsOK(res1)) {
23412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23413 }
23414 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23415 {
23416 arg2 = &temp2;
23417 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23418 }
23419 {
23420 PyThreadState* __tstate = wxPyBeginAllowThreads();
23421 (arg1)->SetRect((wxRect const &)*arg2);
23422 wxPyEndAllowThreads(__tstate);
23423 if (PyErr_Occurred()) SWIG_fail;
23424 }
23425 resultobj = SWIG_Py_Void();
23426 return resultobj;
23427 fail:
23428 return NULL;
23429 }
23430
23431
23432 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23433 PyObject *resultobj = 0;
23434 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23435 wxPoint *arg2 = 0 ;
23436 void *argp1 = 0 ;
23437 int res1 = 0 ;
23438 wxPoint temp2 ;
23439 PyObject * obj0 = 0 ;
23440 PyObject * obj1 = 0 ;
23441 char * kwnames[] = {
23442 (char *) "self",(char *) "pos", NULL
23443 };
23444
23445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23447 if (!SWIG_IsOK(res1)) {
23448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23449 }
23450 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23451 {
23452 arg2 = &temp2;
23453 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 (arg1)->SetPosition((wxPoint const &)*arg2);
23458 wxPyEndAllowThreads(__tstate);
23459 if (PyErr_Occurred()) SWIG_fail;
23460 }
23461 resultobj = SWIG_Py_Void();
23462 return resultobj;
23463 fail:
23464 return NULL;
23465 }
23466
23467
23468 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23469 PyObject *obj;
23470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23471 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23472 return SWIG_Py_Void();
23473 }
23474
23475 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23476 return SWIG_Python_InitShadowInstance(args);
23477 }
23478
23479 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj = 0;
23481 int arg1 = (int) 0 ;
23482 wxPaintEvent *result = 0 ;
23483 int val1 ;
23484 int ecode1 = 0 ;
23485 PyObject * obj0 = 0 ;
23486 char * kwnames[] = {
23487 (char *) "Id", NULL
23488 };
23489
23490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23491 if (obj0) {
23492 ecode1 = SWIG_AsVal_int(obj0, &val1);
23493 if (!SWIG_IsOK(ecode1)) {
23494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23495 }
23496 arg1 = static_cast< int >(val1);
23497 }
23498 {
23499 PyThreadState* __tstate = wxPyBeginAllowThreads();
23500 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23501 wxPyEndAllowThreads(__tstate);
23502 if (PyErr_Occurred()) SWIG_fail;
23503 }
23504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23512 PyObject *obj;
23513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23514 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23515 return SWIG_Py_Void();
23516 }
23517
23518 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23519 return SWIG_Python_InitShadowInstance(args);
23520 }
23521
23522 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj = 0;
23524 int arg1 = (int) 0 ;
23525 wxNcPaintEvent *result = 0 ;
23526 int val1 ;
23527 int ecode1 = 0 ;
23528 PyObject * obj0 = 0 ;
23529 char * kwnames[] = {
23530 (char *) "winid", NULL
23531 };
23532
23533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23534 if (obj0) {
23535 ecode1 = SWIG_AsVal_int(obj0, &val1);
23536 if (!SWIG_IsOK(ecode1)) {
23537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23538 }
23539 arg1 = static_cast< int >(val1);
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23544 wxPyEndAllowThreads(__tstate);
23545 if (PyErr_Occurred()) SWIG_fail;
23546 }
23547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23548 return resultobj;
23549 fail:
23550 return NULL;
23551 }
23552
23553
23554 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23555 PyObject *obj;
23556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23557 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23558 return SWIG_Py_Void();
23559 }
23560
23561 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 return SWIG_Python_InitShadowInstance(args);
23563 }
23564
23565 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 int arg1 = (int) 0 ;
23568 wxDC *arg2 = (wxDC *) NULL ;
23569 wxEraseEvent *result = 0 ;
23570 int val1 ;
23571 int ecode1 = 0 ;
23572 void *argp2 = 0 ;
23573 int res2 = 0 ;
23574 PyObject * obj0 = 0 ;
23575 PyObject * obj1 = 0 ;
23576 char * kwnames[] = {
23577 (char *) "Id",(char *) "dc", NULL
23578 };
23579
23580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23581 if (obj0) {
23582 ecode1 = SWIG_AsVal_int(obj0, &val1);
23583 if (!SWIG_IsOK(ecode1)) {
23584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23585 }
23586 arg1 = static_cast< int >(val1);
23587 }
23588 if (obj1) {
23589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23590 if (!SWIG_IsOK(res2)) {
23591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23592 }
23593 arg2 = reinterpret_cast< wxDC * >(argp2);
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23598 wxPyEndAllowThreads(__tstate);
23599 if (PyErr_Occurred()) SWIG_fail;
23600 }
23601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23602 return resultobj;
23603 fail:
23604 return NULL;
23605 }
23606
23607
23608 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23609 PyObject *resultobj = 0;
23610 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23611 wxDC *result = 0 ;
23612 void *argp1 = 0 ;
23613 int res1 = 0 ;
23614 PyObject *swig_obj[1] ;
23615
23616 if (!args) SWIG_fail;
23617 swig_obj[0] = args;
23618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23621 }
23622 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23626 wxPyEndAllowThreads(__tstate);
23627 if (PyErr_Occurred()) SWIG_fail;
23628 }
23629 {
23630 resultobj = wxPyMake_wxObject(result, (bool)0);
23631 }
23632 return resultobj;
23633 fail:
23634 return NULL;
23635 }
23636
23637
23638 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23639 PyObject *obj;
23640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23641 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23642 return SWIG_Py_Void();
23643 }
23644
23645 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 return SWIG_Python_InitShadowInstance(args);
23647 }
23648
23649 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23650 PyObject *resultobj = 0;
23651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23652 int arg2 = (int) 0 ;
23653 wxFocusEvent *result = 0 ;
23654 int val1 ;
23655 int ecode1 = 0 ;
23656 int val2 ;
23657 int ecode2 = 0 ;
23658 PyObject * obj0 = 0 ;
23659 PyObject * obj1 = 0 ;
23660 char * kwnames[] = {
23661 (char *) "type",(char *) "winid", NULL
23662 };
23663
23664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23665 if (obj0) {
23666 ecode1 = SWIG_AsVal_int(obj0, &val1);
23667 if (!SWIG_IsOK(ecode1)) {
23668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23669 }
23670 arg1 = static_cast< wxEventType >(val1);
23671 }
23672 if (obj1) {
23673 ecode2 = SWIG_AsVal_int(obj1, &val2);
23674 if (!SWIG_IsOK(ecode2)) {
23675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23676 }
23677 arg2 = static_cast< int >(val2);
23678 }
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23686 return resultobj;
23687 fail:
23688 return NULL;
23689 }
23690
23691
23692 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 PyObject *resultobj = 0;
23694 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23695 wxWindow *result = 0 ;
23696 void *argp1 = 0 ;
23697 int res1 = 0 ;
23698 PyObject *swig_obj[1] ;
23699
23700 if (!args) SWIG_fail;
23701 swig_obj[0] = args;
23702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23705 }
23706 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 {
23714 resultobj = wxPyMake_wxObject(result, (bool)0);
23715 }
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj = 0;
23724 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23725 wxWindow *arg2 = (wxWindow *) 0 ;
23726 void *argp1 = 0 ;
23727 int res1 = 0 ;
23728 void *argp2 = 0 ;
23729 int res2 = 0 ;
23730 PyObject * obj0 = 0 ;
23731 PyObject * obj1 = 0 ;
23732 char * kwnames[] = {
23733 (char *) "self",(char *) "win", NULL
23734 };
23735
23736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23738 if (!SWIG_IsOK(res1)) {
23739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23740 }
23741 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23743 if (!SWIG_IsOK(res2)) {
23744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23745 }
23746 arg2 = reinterpret_cast< wxWindow * >(argp2);
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 (arg1)->SetWindow(arg2);
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 resultobj = SWIG_Py_Void();
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23761 PyObject *obj;
23762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23763 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23764 return SWIG_Py_Void();
23765 }
23766
23767 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23768 return SWIG_Python_InitShadowInstance(args);
23769 }
23770
23771 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj = 0;
23773 wxWindow *arg1 = (wxWindow *) NULL ;
23774 wxChildFocusEvent *result = 0 ;
23775 void *argp1 = 0 ;
23776 int res1 = 0 ;
23777 PyObject * obj0 = 0 ;
23778 char * kwnames[] = {
23779 (char *) "win", NULL
23780 };
23781
23782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23783 if (obj0) {
23784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23785 if (!SWIG_IsOK(res1)) {
23786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23787 }
23788 arg1 = reinterpret_cast< wxWindow * >(argp1);
23789 }
23790 {
23791 PyThreadState* __tstate = wxPyBeginAllowThreads();
23792 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23793 wxPyEndAllowThreads(__tstate);
23794 if (PyErr_Occurred()) SWIG_fail;
23795 }
23796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23797 return resultobj;
23798 fail:
23799 return NULL;
23800 }
23801
23802
23803 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23804 PyObject *resultobj = 0;
23805 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23806 wxWindow *result = 0 ;
23807 void *argp1 = 0 ;
23808 int res1 = 0 ;
23809 PyObject *swig_obj[1] ;
23810
23811 if (!args) SWIG_fail;
23812 swig_obj[0] = args;
23813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23814 if (!SWIG_IsOK(res1)) {
23815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23816 }
23817 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23818 {
23819 PyThreadState* __tstate = wxPyBeginAllowThreads();
23820 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 {
23825 resultobj = wxPyMake_wxObject(result, (bool)0);
23826 }
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 PyObject *obj;
23835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23836 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23837 return SWIG_Py_Void();
23838 }
23839
23840 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 return SWIG_Python_InitShadowInstance(args);
23842 }
23843
23844 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = 0;
23846 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23847 bool arg2 = (bool) true ;
23848 int arg3 = (int) 0 ;
23849 wxActivateEvent *result = 0 ;
23850 int val1 ;
23851 int ecode1 = 0 ;
23852 bool val2 ;
23853 int ecode2 = 0 ;
23854 int val3 ;
23855 int ecode3 = 0 ;
23856 PyObject * obj0 = 0 ;
23857 PyObject * obj1 = 0 ;
23858 PyObject * obj2 = 0 ;
23859 char * kwnames[] = {
23860 (char *) "type",(char *) "active",(char *) "Id", NULL
23861 };
23862
23863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23864 if (obj0) {
23865 ecode1 = SWIG_AsVal_int(obj0, &val1);
23866 if (!SWIG_IsOK(ecode1)) {
23867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23868 }
23869 arg1 = static_cast< wxEventType >(val1);
23870 }
23871 if (obj1) {
23872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23873 if (!SWIG_IsOK(ecode2)) {
23874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23875 }
23876 arg2 = static_cast< bool >(val2);
23877 }
23878 if (obj2) {
23879 ecode3 = SWIG_AsVal_int(obj2, &val3);
23880 if (!SWIG_IsOK(ecode3)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23882 }
23883 arg3 = static_cast< int >(val3);
23884 }
23885 {
23886 PyThreadState* __tstate = wxPyBeginAllowThreads();
23887 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23888 wxPyEndAllowThreads(__tstate);
23889 if (PyErr_Occurred()) SWIG_fail;
23890 }
23891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23892 return resultobj;
23893 fail:
23894 return NULL;
23895 }
23896
23897
23898 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23899 PyObject *resultobj = 0;
23900 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23901 bool result;
23902 void *argp1 = 0 ;
23903 int res1 = 0 ;
23904 PyObject *swig_obj[1] ;
23905
23906 if (!args) SWIG_fail;
23907 swig_obj[0] = args;
23908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23909 if (!SWIG_IsOK(res1)) {
23910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23911 }
23912 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23916 wxPyEndAllowThreads(__tstate);
23917 if (PyErr_Occurred()) SWIG_fail;
23918 }
23919 {
23920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23921 }
23922 return resultobj;
23923 fail:
23924 return NULL;
23925 }
23926
23927
23928 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23929 PyObject *obj;
23930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23931 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23932 return SWIG_Py_Void();
23933 }
23934
23935 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 return SWIG_Python_InitShadowInstance(args);
23937 }
23938
23939 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj = 0;
23941 int arg1 = (int) 0 ;
23942 wxInitDialogEvent *result = 0 ;
23943 int val1 ;
23944 int ecode1 = 0 ;
23945 PyObject * obj0 = 0 ;
23946 char * kwnames[] = {
23947 (char *) "Id", NULL
23948 };
23949
23950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23951 if (obj0) {
23952 ecode1 = SWIG_AsVal_int(obj0, &val1);
23953 if (!SWIG_IsOK(ecode1)) {
23954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23955 }
23956 arg1 = static_cast< int >(val1);
23957 }
23958 {
23959 PyThreadState* __tstate = wxPyBeginAllowThreads();
23960 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23972 PyObject *obj;
23973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23974 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23975 return SWIG_Py_Void();
23976 }
23977
23978 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23979 return SWIG_Python_InitShadowInstance(args);
23980 }
23981
23982 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23983 PyObject *resultobj = 0;
23984 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23985 int arg2 = (int) 0 ;
23986 wxMenu *arg3 = (wxMenu *) NULL ;
23987 wxMenuEvent *result = 0 ;
23988 int val1 ;
23989 int ecode1 = 0 ;
23990 int val2 ;
23991 int ecode2 = 0 ;
23992 void *argp3 = 0 ;
23993 int res3 = 0 ;
23994 PyObject * obj0 = 0 ;
23995 PyObject * obj1 = 0 ;
23996 PyObject * obj2 = 0 ;
23997 char * kwnames[] = {
23998 (char *) "type",(char *) "winid",(char *) "menu", NULL
23999 };
24000
24001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24002 if (obj0) {
24003 ecode1 = SWIG_AsVal_int(obj0, &val1);
24004 if (!SWIG_IsOK(ecode1)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24006 }
24007 arg1 = static_cast< wxEventType >(val1);
24008 }
24009 if (obj1) {
24010 ecode2 = SWIG_AsVal_int(obj1, &val2);
24011 if (!SWIG_IsOK(ecode2)) {
24012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24013 }
24014 arg2 = static_cast< int >(val2);
24015 }
24016 if (obj2) {
24017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24018 if (!SWIG_IsOK(res3)) {
24019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24020 }
24021 arg3 = reinterpret_cast< wxMenu * >(argp3);
24022 }
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24030 return resultobj;
24031 fail:
24032 return NULL;
24033 }
24034
24035
24036 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24037 PyObject *resultobj = 0;
24038 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24039 int result;
24040 void *argp1 = 0 ;
24041 int res1 = 0 ;
24042 PyObject *swig_obj[1] ;
24043
24044 if (!args) SWIG_fail;
24045 swig_obj[0] = args;
24046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24047 if (!SWIG_IsOK(res1)) {
24048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24049 }
24050 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_From_int(static_cast< int >(result));
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *resultobj = 0;
24066 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24067 bool result;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 PyObject *swig_obj[1] ;
24071
24072 if (!args) SWIG_fail;
24073 swig_obj[0] = args;
24074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24077 }
24078 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 {
24086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24087 }
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24095 PyObject *resultobj = 0;
24096 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24097 wxMenu *result = 0 ;
24098 void *argp1 = 0 ;
24099 int res1 = 0 ;
24100 PyObject *swig_obj[1] ;
24101
24102 if (!args) SWIG_fail;
24103 swig_obj[0] = args;
24104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24105 if (!SWIG_IsOK(res1)) {
24106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24107 }
24108 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 {
24116 resultobj = wxPyMake_wxObject(result, (bool)0);
24117 }
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 PyObject *obj;
24126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24127 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24128 return SWIG_Py_Void();
24129 }
24130
24131 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24132 return SWIG_Python_InitShadowInstance(args);
24133 }
24134
24135 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24136 PyObject *resultobj = 0;
24137 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24138 int arg2 = (int) 0 ;
24139 wxCloseEvent *result = 0 ;
24140 int val1 ;
24141 int ecode1 = 0 ;
24142 int val2 ;
24143 int ecode2 = 0 ;
24144 PyObject * obj0 = 0 ;
24145 PyObject * obj1 = 0 ;
24146 char * kwnames[] = {
24147 (char *) "type",(char *) "winid", NULL
24148 };
24149
24150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24151 if (obj0) {
24152 ecode1 = SWIG_AsVal_int(obj0, &val1);
24153 if (!SWIG_IsOK(ecode1)) {
24154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24155 }
24156 arg1 = static_cast< wxEventType >(val1);
24157 }
24158 if (obj1) {
24159 ecode2 = SWIG_AsVal_int(obj1, &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24162 }
24163 arg2 = static_cast< int >(val2);
24164 }
24165 {
24166 PyThreadState* __tstate = wxPyBeginAllowThreads();
24167 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24168 wxPyEndAllowThreads(__tstate);
24169 if (PyErr_Occurred()) SWIG_fail;
24170 }
24171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj = 0;
24180 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24181 bool arg2 ;
24182 void *argp1 = 0 ;
24183 int res1 = 0 ;
24184 bool val2 ;
24185 int ecode2 = 0 ;
24186 PyObject * obj0 = 0 ;
24187 PyObject * obj1 = 0 ;
24188 char * kwnames[] = {
24189 (char *) "self",(char *) "logOff", NULL
24190 };
24191
24192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24194 if (!SWIG_IsOK(res1)) {
24195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24196 }
24197 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24198 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24199 if (!SWIG_IsOK(ecode2)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24201 }
24202 arg2 = static_cast< bool >(val2);
24203 {
24204 PyThreadState* __tstate = wxPyBeginAllowThreads();
24205 (arg1)->SetLoggingOff(arg2);
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_Py_Void();
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24217 PyObject *resultobj = 0;
24218 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24219 bool result;
24220 void *argp1 = 0 ;
24221 int res1 = 0 ;
24222 PyObject *swig_obj[1] ;
24223
24224 if (!args) SWIG_fail;
24225 swig_obj[0] = args;
24226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 {
24232 PyThreadState* __tstate = wxPyBeginAllowThreads();
24233 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24234 wxPyEndAllowThreads(__tstate);
24235 if (PyErr_Occurred()) SWIG_fail;
24236 }
24237 {
24238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24239 }
24240 return resultobj;
24241 fail:
24242 return NULL;
24243 }
24244
24245
24246 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24247 PyObject *resultobj = 0;
24248 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24249 bool arg2 = (bool) true ;
24250 void *argp1 = 0 ;
24251 int res1 = 0 ;
24252 bool val2 ;
24253 int ecode2 = 0 ;
24254 PyObject * obj0 = 0 ;
24255 PyObject * obj1 = 0 ;
24256 char * kwnames[] = {
24257 (char *) "self",(char *) "veto", NULL
24258 };
24259
24260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24264 }
24265 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24266 if (obj1) {
24267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24268 if (!SWIG_IsOK(ecode2)) {
24269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24270 }
24271 arg2 = static_cast< bool >(val2);
24272 }
24273 {
24274 PyThreadState* __tstate = wxPyBeginAllowThreads();
24275 (arg1)->Veto(arg2);
24276 wxPyEndAllowThreads(__tstate);
24277 if (PyErr_Occurred()) SWIG_fail;
24278 }
24279 resultobj = SWIG_Py_Void();
24280 return resultobj;
24281 fail:
24282 return NULL;
24283 }
24284
24285
24286 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24287 PyObject *resultobj = 0;
24288 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24289 bool result;
24290 void *argp1 = 0 ;
24291 int res1 = 0 ;
24292 PyObject *swig_obj[1] ;
24293
24294 if (!args) SWIG_fail;
24295 swig_obj[0] = args;
24296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24297 if (!SWIG_IsOK(res1)) {
24298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24299 }
24300 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24301 {
24302 PyThreadState* __tstate = wxPyBeginAllowThreads();
24303 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24304 wxPyEndAllowThreads(__tstate);
24305 if (PyErr_Occurred()) SWIG_fail;
24306 }
24307 {
24308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24309 }
24310 return resultobj;
24311 fail:
24312 return NULL;
24313 }
24314
24315
24316 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24317 PyObject *resultobj = 0;
24318 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24319 bool arg2 ;
24320 void *argp1 = 0 ;
24321 int res1 = 0 ;
24322 bool val2 ;
24323 int ecode2 = 0 ;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char * kwnames[] = {
24327 (char *) "self",(char *) "canVeto", NULL
24328 };
24329
24330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24332 if (!SWIG_IsOK(res1)) {
24333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24334 }
24335 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24336 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24337 if (!SWIG_IsOK(ecode2)) {
24338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24339 }
24340 arg2 = static_cast< bool >(val2);
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 (arg1)->SetCanVeto(arg2);
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 resultobj = SWIG_Py_Void();
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24355 PyObject *resultobj = 0;
24356 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24357 bool result;
24358 void *argp1 = 0 ;
24359 int res1 = 0 ;
24360 PyObject *swig_obj[1] ;
24361
24362 if (!args) SWIG_fail;
24363 swig_obj[0] = args;
24364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24365 if (!SWIG_IsOK(res1)) {
24366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24367 }
24368 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24369 {
24370 PyThreadState* __tstate = wxPyBeginAllowThreads();
24371 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 {
24376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24377 }
24378 return resultobj;
24379 fail:
24380 return NULL;
24381 }
24382
24383
24384 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24385 PyObject *obj;
24386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24387 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24388 return SWIG_Py_Void();
24389 }
24390
24391 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24392 return SWIG_Python_InitShadowInstance(args);
24393 }
24394
24395 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24396 PyObject *resultobj = 0;
24397 int arg1 = (int) 0 ;
24398 bool arg2 = (bool) false ;
24399 wxShowEvent *result = 0 ;
24400 int val1 ;
24401 int ecode1 = 0 ;
24402 bool val2 ;
24403 int ecode2 = 0 ;
24404 PyObject * obj0 = 0 ;
24405 PyObject * obj1 = 0 ;
24406 char * kwnames[] = {
24407 (char *) "winid",(char *) "show", NULL
24408 };
24409
24410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24411 if (obj0) {
24412 ecode1 = SWIG_AsVal_int(obj0, &val1);
24413 if (!SWIG_IsOK(ecode1)) {
24414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24415 }
24416 arg1 = static_cast< int >(val1);
24417 }
24418 if (obj1) {
24419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24420 if (!SWIG_IsOK(ecode2)) {
24421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24422 }
24423 arg2 = static_cast< bool >(val2);
24424 }
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24428 wxPyEndAllowThreads(__tstate);
24429 if (PyErr_Occurred()) SWIG_fail;
24430 }
24431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24432 return resultobj;
24433 fail:
24434 return NULL;
24435 }
24436
24437
24438 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24439 PyObject *resultobj = 0;
24440 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24441 bool arg2 ;
24442 void *argp1 = 0 ;
24443 int res1 = 0 ;
24444 bool val2 ;
24445 int ecode2 = 0 ;
24446 PyObject * obj0 = 0 ;
24447 PyObject * obj1 = 0 ;
24448 char * kwnames[] = {
24449 (char *) "self",(char *) "show", NULL
24450 };
24451
24452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24454 if (!SWIG_IsOK(res1)) {
24455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24456 }
24457 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24459 if (!SWIG_IsOK(ecode2)) {
24460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24461 }
24462 arg2 = static_cast< bool >(val2);
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 (arg1)->SetShow(arg2);
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_Py_Void();
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 PyObject *resultobj = 0;
24478 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24479 bool result;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 PyObject *swig_obj[1] ;
24483
24484 if (!args) SWIG_fail;
24485 swig_obj[0] = args;
24486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24489 }
24490 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 {
24498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24499 }
24500 return resultobj;
24501 fail:
24502 return NULL;
24503 }
24504
24505
24506 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24507 PyObject *obj;
24508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24509 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24510 return SWIG_Py_Void();
24511 }
24512
24513 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24514 return SWIG_Python_InitShadowInstance(args);
24515 }
24516
24517 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24518 PyObject *resultobj = 0;
24519 int arg1 = (int) 0 ;
24520 bool arg2 = (bool) true ;
24521 wxIconizeEvent *result = 0 ;
24522 int val1 ;
24523 int ecode1 = 0 ;
24524 bool val2 ;
24525 int ecode2 = 0 ;
24526 PyObject * obj0 = 0 ;
24527 PyObject * obj1 = 0 ;
24528 char * kwnames[] = {
24529 (char *) "id",(char *) "iconized", NULL
24530 };
24531
24532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24533 if (obj0) {
24534 ecode1 = SWIG_AsVal_int(obj0, &val1);
24535 if (!SWIG_IsOK(ecode1)) {
24536 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24537 }
24538 arg1 = static_cast< int >(val1);
24539 }
24540 if (obj1) {
24541 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24542 if (!SWIG_IsOK(ecode2)) {
24543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24544 }
24545 arg2 = static_cast< bool >(val2);
24546 }
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 PyObject *resultobj = 0;
24562 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24563 bool result;
24564 void *argp1 = 0 ;
24565 int res1 = 0 ;
24566 PyObject *swig_obj[1] ;
24567
24568 if (!args) SWIG_fail;
24569 swig_obj[0] = args;
24570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24571 if (!SWIG_IsOK(res1)) {
24572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24573 }
24574 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 result = (bool)(arg1)->Iconized();
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 {
24582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24583 }
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591 PyObject *obj;
24592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24593 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24594 return SWIG_Py_Void();
24595 }
24596
24597 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24598 return SWIG_Python_InitShadowInstance(args);
24599 }
24600
24601 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24602 PyObject *resultobj = 0;
24603 int arg1 = (int) 0 ;
24604 wxMaximizeEvent *result = 0 ;
24605 int val1 ;
24606 int ecode1 = 0 ;
24607 PyObject * obj0 = 0 ;
24608 char * kwnames[] = {
24609 (char *) "id", NULL
24610 };
24611
24612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24613 if (obj0) {
24614 ecode1 = SWIG_AsVal_int(obj0, &val1);
24615 if (!SWIG_IsOK(ecode1)) {
24616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24617 }
24618 arg1 = static_cast< int >(val1);
24619 }
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24623 wxPyEndAllowThreads(__tstate);
24624 if (PyErr_Occurred()) SWIG_fail;
24625 }
24626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24627 return resultobj;
24628 fail:
24629 return NULL;
24630 }
24631
24632
24633 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24634 PyObject *obj;
24635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24636 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24637 return SWIG_Py_Void();
24638 }
24639
24640 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24641 return SWIG_Python_InitShadowInstance(args);
24642 }
24643
24644 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24645 PyObject *resultobj = 0;
24646 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24647 wxPoint result;
24648 void *argp1 = 0 ;
24649 int res1 = 0 ;
24650 PyObject *swig_obj[1] ;
24651
24652 if (!args) SWIG_fail;
24653 swig_obj[0] = args;
24654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24655 if (!SWIG_IsOK(res1)) {
24656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24657 }
24658 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (arg1)->GetPosition();
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 PyObject *resultobj = 0;
24674 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24675 int result;
24676 void *argp1 = 0 ;
24677 int res1 = 0 ;
24678 PyObject *swig_obj[1] ;
24679
24680 if (!args) SWIG_fail;
24681 swig_obj[0] = args;
24682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24683 if (!SWIG_IsOK(res1)) {
24684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24685 }
24686 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = (int)(arg1)->GetNumberOfFiles();
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 resultobj = SWIG_From_int(static_cast< int >(result));
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24701 PyObject *resultobj = 0;
24702 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24703 PyObject *result = 0 ;
24704 void *argp1 = 0 ;
24705 int res1 = 0 ;
24706 PyObject *swig_obj[1] ;
24707
24708 if (!args) SWIG_fail;
24709 swig_obj[0] = args;
24710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24711 if (!SWIG_IsOK(res1)) {
24712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24713 }
24714 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24715 {
24716 PyThreadState* __tstate = wxPyBeginAllowThreads();
24717 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24718 wxPyEndAllowThreads(__tstate);
24719 if (PyErr_Occurred()) SWIG_fail;
24720 }
24721 resultobj = result;
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24729 PyObject *obj;
24730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24731 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24732 return SWIG_Py_Void();
24733 }
24734
24735 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24736 PyObject *resultobj = 0;
24737 int arg1 = (int) 0 ;
24738 wxUpdateUIEvent *result = 0 ;
24739 int val1 ;
24740 int ecode1 = 0 ;
24741 PyObject * obj0 = 0 ;
24742 char * kwnames[] = {
24743 (char *) "commandId", NULL
24744 };
24745
24746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24747 if (obj0) {
24748 ecode1 = SWIG_AsVal_int(obj0, &val1);
24749 if (!SWIG_IsOK(ecode1)) {
24750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24751 }
24752 arg1 = static_cast< int >(val1);
24753 }
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 PyObject *resultobj = 0;
24769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24770 bool result;
24771 void *argp1 = 0 ;
24772 int res1 = 0 ;
24773 PyObject *swig_obj[1] ;
24774
24775 if (!args) SWIG_fail;
24776 swig_obj[0] = args;
24777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24778 if (!SWIG_IsOK(res1)) {
24779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24780 }
24781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 {
24789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24790 }
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24798 PyObject *resultobj = 0;
24799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24800 bool result;
24801 void *argp1 = 0 ;
24802 int res1 = 0 ;
24803 PyObject *swig_obj[1] ;
24804
24805 if (!args) SWIG_fail;
24806 swig_obj[0] = args;
24807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24808 if (!SWIG_IsOK(res1)) {
24809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24810 }
24811 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24812 {
24813 PyThreadState* __tstate = wxPyBeginAllowThreads();
24814 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24815 wxPyEndAllowThreads(__tstate);
24816 if (PyErr_Occurred()) SWIG_fail;
24817 }
24818 {
24819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24820 }
24821 return resultobj;
24822 fail:
24823 return NULL;
24824 }
24825
24826
24827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24828 PyObject *resultobj = 0;
24829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24830 bool result;
24831 void *argp1 = 0 ;
24832 int res1 = 0 ;
24833 PyObject *swig_obj[1] ;
24834
24835 if (!args) SWIG_fail;
24836 swig_obj[0] = args;
24837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24838 if (!SWIG_IsOK(res1)) {
24839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24840 }
24841 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 {
24849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24850 }
24851 return resultobj;
24852 fail:
24853 return NULL;
24854 }
24855
24856
24857 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24858 PyObject *resultobj = 0;
24859 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24860 wxString result;
24861 void *argp1 = 0 ;
24862 int res1 = 0 ;
24863 PyObject *swig_obj[1] ;
24864
24865 if (!args) SWIG_fail;
24866 swig_obj[0] = args;
24867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24868 if (!SWIG_IsOK(res1)) {
24869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24870 }
24871 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 #if wxUSE_UNICODE
24880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24881 #else
24882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24883 #endif
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24904 }
24905 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24906 {
24907 PyThreadState* __tstate = wxPyBeginAllowThreads();
24908 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24909 wxPyEndAllowThreads(__tstate);
24910 if (PyErr_Occurred()) SWIG_fail;
24911 }
24912 {
24913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24914 }
24915 return resultobj;
24916 fail:
24917 return NULL;
24918 }
24919
24920
24921 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24922 PyObject *resultobj = 0;
24923 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24924 bool result;
24925 void *argp1 = 0 ;
24926 int res1 = 0 ;
24927 PyObject *swig_obj[1] ;
24928
24929 if (!args) SWIG_fail;
24930 swig_obj[0] = args;
24931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24932 if (!SWIG_IsOK(res1)) {
24933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24934 }
24935 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24939 wxPyEndAllowThreads(__tstate);
24940 if (PyErr_Occurred()) SWIG_fail;
24941 }
24942 {
24943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24944 }
24945 return resultobj;
24946 fail:
24947 return NULL;
24948 }
24949
24950
24951 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24952 PyObject *resultobj = 0;
24953 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24954 bool result;
24955 void *argp1 = 0 ;
24956 int res1 = 0 ;
24957 PyObject *swig_obj[1] ;
24958
24959 if (!args) SWIG_fail;
24960 swig_obj[0] = args;
24961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24962 if (!SWIG_IsOK(res1)) {
24963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24964 }
24965 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24966 {
24967 PyThreadState* __tstate = wxPyBeginAllowThreads();
24968 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 {
24973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24982 PyObject *resultobj = 0;
24983 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24984 bool result;
24985 void *argp1 = 0 ;
24986 int res1 = 0 ;
24987 PyObject *swig_obj[1] ;
24988
24989 if (!args) SWIG_fail;
24990 swig_obj[0] = args;
24991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24992 if (!SWIG_IsOK(res1)) {
24993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24994 }
24995 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24999 wxPyEndAllowThreads(__tstate);
25000 if (PyErr_Occurred()) SWIG_fail;
25001 }
25002 {
25003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25004 }
25005 return resultobj;
25006 fail:
25007 return NULL;
25008 }
25009
25010
25011 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25012 PyObject *resultobj = 0;
25013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25014 bool arg2 ;
25015 void *argp1 = 0 ;
25016 int res1 = 0 ;
25017 bool val2 ;
25018 int ecode2 = 0 ;
25019 PyObject * obj0 = 0 ;
25020 PyObject * obj1 = 0 ;
25021 char * kwnames[] = {
25022 (char *) "self",(char *) "check", NULL
25023 };
25024
25025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25029 }
25030 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25032 if (!SWIG_IsOK(ecode2)) {
25033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25034 }
25035 arg2 = static_cast< bool >(val2);
25036 {
25037 PyThreadState* __tstate = wxPyBeginAllowThreads();
25038 (arg1)->Check(arg2);
25039 wxPyEndAllowThreads(__tstate);
25040 if (PyErr_Occurred()) SWIG_fail;
25041 }
25042 resultobj = SWIG_Py_Void();
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj = 0;
25051 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25052 bool arg2 ;
25053 void *argp1 = 0 ;
25054 int res1 = 0 ;
25055 bool val2 ;
25056 int ecode2 = 0 ;
25057 PyObject * obj0 = 0 ;
25058 PyObject * obj1 = 0 ;
25059 char * kwnames[] = {
25060 (char *) "self",(char *) "enable", NULL
25061 };
25062
25063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25067 }
25068 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25070 if (!SWIG_IsOK(ecode2)) {
25071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25072 }
25073 arg2 = static_cast< bool >(val2);
25074 {
25075 PyThreadState* __tstate = wxPyBeginAllowThreads();
25076 (arg1)->Enable(arg2);
25077 wxPyEndAllowThreads(__tstate);
25078 if (PyErr_Occurred()) SWIG_fail;
25079 }
25080 resultobj = SWIG_Py_Void();
25081 return resultobj;
25082 fail:
25083 return NULL;
25084 }
25085
25086
25087 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25088 PyObject *resultobj = 0;
25089 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25090 bool arg2 ;
25091 void *argp1 = 0 ;
25092 int res1 = 0 ;
25093 bool val2 ;
25094 int ecode2 = 0 ;
25095 PyObject * obj0 = 0 ;
25096 PyObject * obj1 = 0 ;
25097 char * kwnames[] = {
25098 (char *) "self",(char *) "show", NULL
25099 };
25100
25101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25103 if (!SWIG_IsOK(res1)) {
25104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25105 }
25106 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25108 if (!SWIG_IsOK(ecode2)) {
25109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25110 }
25111 arg2 = static_cast< bool >(val2);
25112 {
25113 PyThreadState* __tstate = wxPyBeginAllowThreads();
25114 (arg1)->Show(arg2);
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 resultobj = SWIG_Py_Void();
25119 return resultobj;
25120 fail:
25121 return NULL;
25122 }
25123
25124
25125 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25126 PyObject *resultobj = 0;
25127 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25128 wxString *arg2 = 0 ;
25129 void *argp1 = 0 ;
25130 int res1 = 0 ;
25131 bool temp2 = false ;
25132 PyObject * obj0 = 0 ;
25133 PyObject * obj1 = 0 ;
25134 char * kwnames[] = {
25135 (char *) "self",(char *) "text", NULL
25136 };
25137
25138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25140 if (!SWIG_IsOK(res1)) {
25141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25142 }
25143 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25144 {
25145 arg2 = wxString_in_helper(obj1);
25146 if (arg2 == NULL) SWIG_fail;
25147 temp2 = true;
25148 }
25149 {
25150 PyThreadState* __tstate = wxPyBeginAllowThreads();
25151 (arg1)->SetText((wxString const &)*arg2);
25152 wxPyEndAllowThreads(__tstate);
25153 if (PyErr_Occurred()) SWIG_fail;
25154 }
25155 resultobj = SWIG_Py_Void();
25156 {
25157 if (temp2)
25158 delete arg2;
25159 }
25160 return resultobj;
25161 fail:
25162 {
25163 if (temp2)
25164 delete arg2;
25165 }
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj = 0;
25172 long arg1 ;
25173 long val1 ;
25174 int ecode1 = 0 ;
25175 PyObject * obj0 = 0 ;
25176 char * kwnames[] = {
25177 (char *) "updateInterval", NULL
25178 };
25179
25180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25181 ecode1 = SWIG_AsVal_long(obj0, &val1);
25182 if (!SWIG_IsOK(ecode1)) {
25183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25184 }
25185 arg1 = static_cast< long >(val1);
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 wxUpdateUIEvent::SetUpdateInterval(arg1);
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 resultobj = SWIG_Py_Void();
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 long result;
25202
25203 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 resultobj = SWIG_From_long(static_cast< long >(result));
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25218 PyObject *resultobj = 0;
25219 wxWindow *arg1 = (wxWindow *) 0 ;
25220 bool result;
25221 void *argp1 = 0 ;
25222 int res1 = 0 ;
25223 PyObject * obj0 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "win", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25230 if (!SWIG_IsOK(res1)) {
25231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25232 }
25233 arg1 = reinterpret_cast< wxWindow * >(argp1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 {
25241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25242 }
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25250 PyObject *resultobj = 0;
25251
25252 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25253 {
25254 PyThreadState* __tstate = wxPyBeginAllowThreads();
25255 wxUpdateUIEvent::ResetUpdateTime();
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_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25267 PyObject *resultobj = 0;
25268 wxUpdateUIMode arg1 ;
25269 int val1 ;
25270 int ecode1 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 char * kwnames[] = {
25273 (char *) "mode", NULL
25274 };
25275
25276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25277 ecode1 = SWIG_AsVal_int(obj0, &val1);
25278 if (!SWIG_IsOK(ecode1)) {
25279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25280 }
25281 arg1 = static_cast< wxUpdateUIMode >(val1);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 wxUpdateUIEvent::SetMode(arg1);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_Py_Void();
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25296 PyObject *resultobj = 0;
25297 wxUpdateUIMode result;
25298
25299 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25303 wxPyEndAllowThreads(__tstate);
25304 if (PyErr_Occurred()) SWIG_fail;
25305 }
25306 resultobj = SWIG_From_int(static_cast< int >(result));
25307 return resultobj;
25308 fail:
25309 return NULL;
25310 }
25311
25312
25313 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25314 PyObject *obj;
25315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25316 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25317 return SWIG_Py_Void();
25318 }
25319
25320 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 return SWIG_Python_InitShadowInstance(args);
25322 }
25323
25324 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *resultobj = 0;
25326 wxSysColourChangedEvent *result = 0 ;
25327
25328 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25329 {
25330 PyThreadState* __tstate = wxPyBeginAllowThreads();
25331 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25336 return resultobj;
25337 fail:
25338 return NULL;
25339 }
25340
25341
25342 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25343 PyObject *obj;
25344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25345 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25346 return SWIG_Py_Void();
25347 }
25348
25349 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25350 return SWIG_Python_InitShadowInstance(args);
25351 }
25352
25353 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25354 PyObject *resultobj = 0;
25355 int arg1 = (int) 0 ;
25356 wxWindow *arg2 = (wxWindow *) NULL ;
25357 wxMouseCaptureChangedEvent *result = 0 ;
25358 int val1 ;
25359 int ecode1 = 0 ;
25360 void *argp2 = 0 ;
25361 int res2 = 0 ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 char * kwnames[] = {
25365 (char *) "winid",(char *) "gainedCapture", NULL
25366 };
25367
25368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25369 if (obj0) {
25370 ecode1 = SWIG_AsVal_int(obj0, &val1);
25371 if (!SWIG_IsOK(ecode1)) {
25372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25373 }
25374 arg1 = static_cast< int >(val1);
25375 }
25376 if (obj1) {
25377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25378 if (!SWIG_IsOK(res2)) {
25379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25380 }
25381 arg2 = reinterpret_cast< wxWindow * >(argp2);
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25397 PyObject *resultobj = 0;
25398 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25399 wxWindow *result = 0 ;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 PyObject *swig_obj[1] ;
25403
25404 if (!args) SWIG_fail;
25405 swig_obj[0] = args;
25406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25407 if (!SWIG_IsOK(res1)) {
25408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25409 }
25410 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25411 {
25412 PyThreadState* __tstate = wxPyBeginAllowThreads();
25413 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25414 wxPyEndAllowThreads(__tstate);
25415 if (PyErr_Occurred()) SWIG_fail;
25416 }
25417 {
25418 resultobj = wxPyMake_wxObject(result, (bool)0);
25419 }
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25427 PyObject *obj;
25428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25429 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25430 return SWIG_Py_Void();
25431 }
25432
25433 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25434 return SWIG_Python_InitShadowInstance(args);
25435 }
25436
25437 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25438 PyObject *resultobj = 0;
25439 wxDisplayChangedEvent *result = 0 ;
25440
25441 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25442 {
25443 PyThreadState* __tstate = wxPyBeginAllowThreads();
25444 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25445 wxPyEndAllowThreads(__tstate);
25446 if (PyErr_Occurred()) SWIG_fail;
25447 }
25448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *obj;
25457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25458 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25459 return SWIG_Py_Void();
25460 }
25461
25462 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25463 return SWIG_Python_InitShadowInstance(args);
25464 }
25465
25466 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj = 0;
25468 int arg1 = (int) 0 ;
25469 wxPaletteChangedEvent *result = 0 ;
25470 int val1 ;
25471 int ecode1 = 0 ;
25472 PyObject * obj0 = 0 ;
25473 char * kwnames[] = {
25474 (char *) "id", NULL
25475 };
25476
25477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25478 if (obj0) {
25479 ecode1 = SWIG_AsVal_int(obj0, &val1);
25480 if (!SWIG_IsOK(ecode1)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25482 }
25483 arg1 = static_cast< int >(val1);
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25499 PyObject *resultobj = 0;
25500 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25501 wxWindow *arg2 = (wxWindow *) 0 ;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 void *argp2 = 0 ;
25505 int res2 = 0 ;
25506 PyObject * obj0 = 0 ;
25507 PyObject * obj1 = 0 ;
25508 char * kwnames[] = {
25509 (char *) "self",(char *) "win", NULL
25510 };
25511
25512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25514 if (!SWIG_IsOK(res1)) {
25515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25516 }
25517 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25518 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25519 if (!SWIG_IsOK(res2)) {
25520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25521 }
25522 arg2 = reinterpret_cast< wxWindow * >(argp2);
25523 {
25524 PyThreadState* __tstate = wxPyBeginAllowThreads();
25525 (arg1)->SetChangedWindow(arg2);
25526 wxPyEndAllowThreads(__tstate);
25527 if (PyErr_Occurred()) SWIG_fail;
25528 }
25529 resultobj = SWIG_Py_Void();
25530 return resultobj;
25531 fail:
25532 return NULL;
25533 }
25534
25535
25536 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25537 PyObject *resultobj = 0;
25538 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25539 wxWindow *result = 0 ;
25540 void *argp1 = 0 ;
25541 int res1 = 0 ;
25542 PyObject *swig_obj[1] ;
25543
25544 if (!args) SWIG_fail;
25545 swig_obj[0] = args;
25546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25547 if (!SWIG_IsOK(res1)) {
25548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25549 }
25550 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25551 {
25552 PyThreadState* __tstate = wxPyBeginAllowThreads();
25553 result = (wxWindow *)(arg1)->GetChangedWindow();
25554 wxPyEndAllowThreads(__tstate);
25555 if (PyErr_Occurred()) SWIG_fail;
25556 }
25557 {
25558 resultobj = wxPyMake_wxObject(result, (bool)0);
25559 }
25560 return resultobj;
25561 fail:
25562 return NULL;
25563 }
25564
25565
25566 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 PyObject *obj;
25568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25569 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25570 return SWIG_Py_Void();
25571 }
25572
25573 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25574 return SWIG_Python_InitShadowInstance(args);
25575 }
25576
25577 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj = 0;
25579 int arg1 = (int) 0 ;
25580 wxQueryNewPaletteEvent *result = 0 ;
25581 int val1 ;
25582 int ecode1 = 0 ;
25583 PyObject * obj0 = 0 ;
25584 char * kwnames[] = {
25585 (char *) "winid", NULL
25586 };
25587
25588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25589 if (obj0) {
25590 ecode1 = SWIG_AsVal_int(obj0, &val1);
25591 if (!SWIG_IsOK(ecode1)) {
25592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25593 }
25594 arg1 = static_cast< int >(val1);
25595 }
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25603 return resultobj;
25604 fail:
25605 return NULL;
25606 }
25607
25608
25609 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25610 PyObject *resultobj = 0;
25611 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25612 bool arg2 ;
25613 void *argp1 = 0 ;
25614 int res1 = 0 ;
25615 bool val2 ;
25616 int ecode2 = 0 ;
25617 PyObject * obj0 = 0 ;
25618 PyObject * obj1 = 0 ;
25619 char * kwnames[] = {
25620 (char *) "self",(char *) "realized", NULL
25621 };
25622
25623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25625 if (!SWIG_IsOK(res1)) {
25626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25627 }
25628 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25629 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25630 if (!SWIG_IsOK(ecode2)) {
25631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25632 }
25633 arg2 = static_cast< bool >(val2);
25634 {
25635 PyThreadState* __tstate = wxPyBeginAllowThreads();
25636 (arg1)->SetPaletteRealized(arg2);
25637 wxPyEndAllowThreads(__tstate);
25638 if (PyErr_Occurred()) SWIG_fail;
25639 }
25640 resultobj = SWIG_Py_Void();
25641 return resultobj;
25642 fail:
25643 return NULL;
25644 }
25645
25646
25647 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25648 PyObject *resultobj = 0;
25649 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25650 bool result;
25651 void *argp1 = 0 ;
25652 int res1 = 0 ;
25653 PyObject *swig_obj[1] ;
25654
25655 if (!args) SWIG_fail;
25656 swig_obj[0] = args;
25657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25658 if (!SWIG_IsOK(res1)) {
25659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25660 }
25661 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 {
25669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25670 }
25671 return resultobj;
25672 fail:
25673 return NULL;
25674 }
25675
25676
25677 SWIGINTERN PyObject *QueryNewPaletteEvent_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_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25681 return SWIG_Py_Void();
25682 }
25683
25684 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25685 return SWIG_Python_InitShadowInstance(args);
25686 }
25687
25688 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25689 PyObject *resultobj = 0;
25690 wxNavigationKeyEvent *result = 0 ;
25691
25692 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25696 wxPyEndAllowThreads(__tstate);
25697 if (PyErr_Occurred()) SWIG_fail;
25698 }
25699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25700 return resultobj;
25701 fail:
25702 return NULL;
25703 }
25704
25705
25706 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 PyObject *resultobj = 0;
25708 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25709 bool result;
25710 void *argp1 = 0 ;
25711 int res1 = 0 ;
25712 PyObject *swig_obj[1] ;
25713
25714 if (!args) SWIG_fail;
25715 swig_obj[0] = args;
25716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25719 }
25720 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 {
25728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25729 }
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25737 PyObject *resultobj = 0;
25738 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25739 bool arg2 ;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 bool val2 ;
25743 int ecode2 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 PyObject * obj1 = 0 ;
25746 char * kwnames[] = {
25747 (char *) "self",(char *) "forward", NULL
25748 };
25749
25750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25754 }
25755 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25757 if (!SWIG_IsOK(ecode2)) {
25758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25759 }
25760 arg2 = static_cast< bool >(val2);
25761 {
25762 PyThreadState* __tstate = wxPyBeginAllowThreads();
25763 (arg1)->SetDirection(arg2);
25764 wxPyEndAllowThreads(__tstate);
25765 if (PyErr_Occurred()) SWIG_fail;
25766 }
25767 resultobj = SWIG_Py_Void();
25768 return resultobj;
25769 fail:
25770 return NULL;
25771 }
25772
25773
25774 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25775 PyObject *resultobj = 0;
25776 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25777 bool result;
25778 void *argp1 = 0 ;
25779 int res1 = 0 ;
25780 PyObject *swig_obj[1] ;
25781
25782 if (!args) SWIG_fail;
25783 swig_obj[0] = args;
25784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25787 }
25788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25792 wxPyEndAllowThreads(__tstate);
25793 if (PyErr_Occurred()) SWIG_fail;
25794 }
25795 {
25796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25797 }
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25805 PyObject *resultobj = 0;
25806 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25807 bool arg2 ;
25808 void *argp1 = 0 ;
25809 int res1 = 0 ;
25810 bool val2 ;
25811 int ecode2 = 0 ;
25812 PyObject * obj0 = 0 ;
25813 PyObject * obj1 = 0 ;
25814 char * kwnames[] = {
25815 (char *) "self",(char *) "ischange", NULL
25816 };
25817
25818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25820 if (!SWIG_IsOK(res1)) {
25821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25822 }
25823 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25825 if (!SWIG_IsOK(ecode2)) {
25826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25827 }
25828 arg2 = static_cast< bool >(val2);
25829 {
25830 PyThreadState* __tstate = wxPyBeginAllowThreads();
25831 (arg1)->SetWindowChange(arg2);
25832 wxPyEndAllowThreads(__tstate);
25833 if (PyErr_Occurred()) SWIG_fail;
25834 }
25835 resultobj = SWIG_Py_Void();
25836 return resultobj;
25837 fail:
25838 return NULL;
25839 }
25840
25841
25842 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25843 PyObject *resultobj = 0;
25844 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25845 bool result;
25846 void *argp1 = 0 ;
25847 int res1 = 0 ;
25848 PyObject *swig_obj[1] ;
25849
25850 if (!args) SWIG_fail;
25851 swig_obj[0] = args;
25852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25853 if (!SWIG_IsOK(res1)) {
25854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25855 }
25856 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25860 wxPyEndAllowThreads(__tstate);
25861 if (PyErr_Occurred()) SWIG_fail;
25862 }
25863 {
25864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25865 }
25866 return resultobj;
25867 fail:
25868 return NULL;
25869 }
25870
25871
25872 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25873 PyObject *resultobj = 0;
25874 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25875 bool arg2 ;
25876 void *argp1 = 0 ;
25877 int res1 = 0 ;
25878 bool val2 ;
25879 int ecode2 = 0 ;
25880 PyObject * obj0 = 0 ;
25881 PyObject * obj1 = 0 ;
25882 char * kwnames[] = {
25883 (char *) "self",(char *) "bIs", NULL
25884 };
25885
25886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25888 if (!SWIG_IsOK(res1)) {
25889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25890 }
25891 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25893 if (!SWIG_IsOK(ecode2)) {
25894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25895 }
25896 arg2 = static_cast< bool >(val2);
25897 {
25898 PyThreadState* __tstate = wxPyBeginAllowThreads();
25899 (arg1)->SetFromTab(arg2);
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 resultobj = SWIG_Py_Void();
25904 return resultobj;
25905 fail:
25906 return NULL;
25907 }
25908
25909
25910 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25911 PyObject *resultobj = 0;
25912 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25913 long arg2 ;
25914 void *argp1 = 0 ;
25915 int res1 = 0 ;
25916 long val2 ;
25917 int ecode2 = 0 ;
25918 PyObject * obj0 = 0 ;
25919 PyObject * obj1 = 0 ;
25920 char * kwnames[] = {
25921 (char *) "self",(char *) "flags", NULL
25922 };
25923
25924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25928 }
25929 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25930 ecode2 = SWIG_AsVal_long(obj1, &val2);
25931 if (!SWIG_IsOK(ecode2)) {
25932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25933 }
25934 arg2 = static_cast< long >(val2);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 (arg1)->SetFlags(arg2);
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 resultobj = SWIG_Py_Void();
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25949 PyObject *resultobj = 0;
25950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25951 wxWindow *result = 0 ;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 PyObject *swig_obj[1] ;
25955
25956 if (!args) SWIG_fail;
25957 swig_obj[0] = args;
25958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25959 if (!SWIG_IsOK(res1)) {
25960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25961 }
25962 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25966 wxPyEndAllowThreads(__tstate);
25967 if (PyErr_Occurred()) SWIG_fail;
25968 }
25969 {
25970 resultobj = wxPyMake_wxObject(result, (bool)0);
25971 }
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25979 PyObject *resultobj = 0;
25980 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25981 wxWindow *arg2 = (wxWindow *) 0 ;
25982 void *argp1 = 0 ;
25983 int res1 = 0 ;
25984 void *argp2 = 0 ;
25985 int res2 = 0 ;
25986 PyObject * obj0 = 0 ;
25987 PyObject * obj1 = 0 ;
25988 char * kwnames[] = {
25989 (char *) "self",(char *) "win", NULL
25990 };
25991
25992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25994 if (!SWIG_IsOK(res1)) {
25995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25996 }
25997 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25999 if (!SWIG_IsOK(res2)) {
26000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26001 }
26002 arg2 = reinterpret_cast< wxWindow * >(argp2);
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 (arg1)->SetCurrentFocus(arg2);
26006 wxPyEndAllowThreads(__tstate);
26007 if (PyErr_Occurred()) SWIG_fail;
26008 }
26009 resultobj = SWIG_Py_Void();
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *obj;
26018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26019 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26020 return SWIG_Py_Void();
26021 }
26022
26023 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26024 return SWIG_Python_InitShadowInstance(args);
26025 }
26026
26027 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj = 0;
26029 wxWindow *arg1 = (wxWindow *) NULL ;
26030 wxWindowCreateEvent *result = 0 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "win", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26039 if (obj0) {
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26043 }
26044 arg1 = reinterpret_cast< wxWindow * >(argp1);
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26053 return resultobj;
26054 fail:
26055 return NULL;
26056 }
26057
26058
26059 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26060 PyObject *resultobj = 0;
26061 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26062 wxWindow *result = 0 ;
26063 void *argp1 = 0 ;
26064 int res1 = 0 ;
26065 PyObject *swig_obj[1] ;
26066
26067 if (!args) SWIG_fail;
26068 swig_obj[0] = args;
26069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26070 if (!SWIG_IsOK(res1)) {
26071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26072 }
26073 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 resultobj = wxPyMake_wxObject(result, (bool)0);
26082 }
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26090 PyObject *obj;
26091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26092 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26093 return SWIG_Py_Void();
26094 }
26095
26096 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 return SWIG_Python_InitShadowInstance(args);
26098 }
26099
26100 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxWindow *arg1 = (wxWindow *) NULL ;
26103 wxWindowDestroyEvent *result = 0 ;
26104 void *argp1 = 0 ;
26105 int res1 = 0 ;
26106 PyObject * obj0 = 0 ;
26107 char * kwnames[] = {
26108 (char *) "win", NULL
26109 };
26110
26111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26112 if (obj0) {
26113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26116 }
26117 arg1 = reinterpret_cast< wxWindow * >(argp1);
26118 }
26119 {
26120 PyThreadState* __tstate = wxPyBeginAllowThreads();
26121 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26122 wxPyEndAllowThreads(__tstate);
26123 if (PyErr_Occurred()) SWIG_fail;
26124 }
26125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26133 PyObject *resultobj = 0;
26134 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26135 wxWindow *result = 0 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 PyObject *swig_obj[1] ;
26139
26140 if (!args) SWIG_fail;
26141 swig_obj[0] = args;
26142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26145 }
26146 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 {
26154 resultobj = wxPyMake_wxObject(result, (bool)0);
26155 }
26156 return resultobj;
26157 fail:
26158 return NULL;
26159 }
26160
26161
26162 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26163 PyObject *obj;
26164 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26165 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26166 return SWIG_Py_Void();
26167 }
26168
26169 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26170 return SWIG_Python_InitShadowInstance(args);
26171 }
26172
26173 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26174 PyObject *resultobj = 0;
26175 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26176 int arg2 = (int) 0 ;
26177 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26178 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26179 wxContextMenuEvent *result = 0 ;
26180 int val1 ;
26181 int ecode1 = 0 ;
26182 int val2 ;
26183 int ecode2 = 0 ;
26184 wxPoint temp3 ;
26185 PyObject * obj0 = 0 ;
26186 PyObject * obj1 = 0 ;
26187 PyObject * obj2 = 0 ;
26188 char * kwnames[] = {
26189 (char *) "type",(char *) "winid",(char *) "pt", NULL
26190 };
26191
26192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26193 if (obj0) {
26194 ecode1 = SWIG_AsVal_int(obj0, &val1);
26195 if (!SWIG_IsOK(ecode1)) {
26196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26197 }
26198 arg1 = static_cast< wxEventType >(val1);
26199 }
26200 if (obj1) {
26201 ecode2 = SWIG_AsVal_int(obj1, &val2);
26202 if (!SWIG_IsOK(ecode2)) {
26203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26204 }
26205 arg2 = static_cast< int >(val2);
26206 }
26207 if (obj2) {
26208 {
26209 arg3 = &temp3;
26210 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26211 }
26212 }
26213 {
26214 PyThreadState* __tstate = wxPyBeginAllowThreads();
26215 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26216 wxPyEndAllowThreads(__tstate);
26217 if (PyErr_Occurred()) SWIG_fail;
26218 }
26219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26220 return resultobj;
26221 fail:
26222 return NULL;
26223 }
26224
26225
26226 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26227 PyObject *resultobj = 0;
26228 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26229 wxPoint *result = 0 ;
26230 void *argp1 = 0 ;
26231 int res1 = 0 ;
26232 PyObject *swig_obj[1] ;
26233
26234 if (!args) SWIG_fail;
26235 swig_obj[0] = args;
26236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26237 if (!SWIG_IsOK(res1)) {
26238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26239 }
26240 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 {
26244 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26245 result = (wxPoint *) &_result_ref;
26246 }
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26258 PyObject *resultobj = 0;
26259 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26260 wxPoint *arg2 = 0 ;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 wxPoint temp2 ;
26264 PyObject * obj0 = 0 ;
26265 PyObject * obj1 = 0 ;
26266 char * kwnames[] = {
26267 (char *) "self",(char *) "pos", NULL
26268 };
26269
26270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26274 }
26275 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26276 {
26277 arg2 = &temp2;
26278 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26279 }
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 (arg1)->SetPosition((wxPoint const &)*arg2);
26283 wxPyEndAllowThreads(__tstate);
26284 if (PyErr_Occurred()) SWIG_fail;
26285 }
26286 resultobj = SWIG_Py_Void();
26287 return resultobj;
26288 fail:
26289 return NULL;
26290 }
26291
26292
26293 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26294 PyObject *obj;
26295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26296 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26297 return SWIG_Py_Void();
26298 }
26299
26300 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26301 return SWIG_Python_InitShadowInstance(args);
26302 }
26303
26304 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *resultobj = 0;
26306 wxIdleEvent *result = 0 ;
26307
26308 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26309 {
26310 PyThreadState* __tstate = wxPyBeginAllowThreads();
26311 result = (wxIdleEvent *)new wxIdleEvent();
26312 wxPyEndAllowThreads(__tstate);
26313 if (PyErr_Occurred()) SWIG_fail;
26314 }
26315 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26316 return resultobj;
26317 fail:
26318 return NULL;
26319 }
26320
26321
26322 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26323 PyObject *resultobj = 0;
26324 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26325 bool arg2 = (bool) true ;
26326 void *argp1 = 0 ;
26327 int res1 = 0 ;
26328 bool val2 ;
26329 int ecode2 = 0 ;
26330 PyObject * obj0 = 0 ;
26331 PyObject * obj1 = 0 ;
26332 char * kwnames[] = {
26333 (char *) "self",(char *) "needMore", NULL
26334 };
26335
26336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26338 if (!SWIG_IsOK(res1)) {
26339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26340 }
26341 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26342 if (obj1) {
26343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26344 if (!SWIG_IsOK(ecode2)) {
26345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26346 }
26347 arg2 = static_cast< bool >(val2);
26348 }
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 (arg1)->RequestMore(arg2);
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_Py_Void();
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26365 bool result;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 PyObject *swig_obj[1] ;
26369
26370 if (!args) SWIG_fail;
26371 swig_obj[0] = args;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26375 }
26376 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 {
26384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26385 }
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26393 PyObject *resultobj = 0;
26394 wxIdleMode arg1 ;
26395 int val1 ;
26396 int ecode1 = 0 ;
26397 PyObject * obj0 = 0 ;
26398 char * kwnames[] = {
26399 (char *) "mode", NULL
26400 };
26401
26402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26403 ecode1 = SWIG_AsVal_int(obj0, &val1);
26404 if (!SWIG_IsOK(ecode1)) {
26405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26406 }
26407 arg1 = static_cast< wxIdleMode >(val1);
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 wxIdleEvent::SetMode(arg1);
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_Py_Void();
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *resultobj = 0;
26423 wxIdleMode result;
26424
26425 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxIdleMode)wxIdleEvent::GetMode();
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 resultobj = SWIG_From_int(static_cast< int >(result));
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj = 0;
26441 wxWindow *arg1 = (wxWindow *) 0 ;
26442 bool result;
26443 void *argp1 = 0 ;
26444 int res1 = 0 ;
26445 PyObject * obj0 = 0 ;
26446 char * kwnames[] = {
26447 (char *) "win", NULL
26448 };
26449
26450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26452 if (!SWIG_IsOK(res1)) {
26453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26454 }
26455 arg1 = reinterpret_cast< wxWindow * >(argp1);
26456 {
26457 PyThreadState* __tstate = wxPyBeginAllowThreads();
26458 result = (bool)wxIdleEvent::CanSend(arg1);
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 {
26463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26464 }
26465 return resultobj;
26466 fail:
26467 return NULL;
26468 }
26469
26470
26471 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26472 PyObject *obj;
26473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26474 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26475 return SWIG_Py_Void();
26476 }
26477
26478 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26479 return SWIG_Python_InitShadowInstance(args);
26480 }
26481
26482 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj = 0;
26484 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26485 int arg2 = (int) 0 ;
26486 wxClipboardTextEvent *result = 0 ;
26487 int val1 ;
26488 int ecode1 = 0 ;
26489 int val2 ;
26490 int ecode2 = 0 ;
26491 PyObject * obj0 = 0 ;
26492 PyObject * obj1 = 0 ;
26493 char * kwnames[] = {
26494 (char *) "type",(char *) "winid", NULL
26495 };
26496
26497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26498 if (obj0) {
26499 ecode1 = SWIG_AsVal_int(obj0, &val1);
26500 if (!SWIG_IsOK(ecode1)) {
26501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26502 }
26503 arg1 = static_cast< wxEventType >(val1);
26504 }
26505 if (obj1) {
26506 ecode2 = SWIG_AsVal_int(obj1, &val2);
26507 if (!SWIG_IsOK(ecode2)) {
26508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26509 }
26510 arg2 = static_cast< int >(val2);
26511 }
26512 {
26513 PyThreadState* __tstate = wxPyBeginAllowThreads();
26514 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26515 wxPyEndAllowThreads(__tstate);
26516 if (PyErr_Occurred()) SWIG_fail;
26517 }
26518 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26519 return resultobj;
26520 fail:
26521 return NULL;
26522 }
26523
26524
26525 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26526 PyObject *obj;
26527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26528 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26529 return SWIG_Py_Void();
26530 }
26531
26532 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26533 return SWIG_Python_InitShadowInstance(args);
26534 }
26535
26536 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26537 PyObject *resultobj = 0;
26538 int arg1 = (int) 0 ;
26539 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26540 wxPyEvent *result = 0 ;
26541 int val1 ;
26542 int ecode1 = 0 ;
26543 int val2 ;
26544 int ecode2 = 0 ;
26545 PyObject * obj0 = 0 ;
26546 PyObject * obj1 = 0 ;
26547 char * kwnames[] = {
26548 (char *) "winid",(char *) "eventType", NULL
26549 };
26550
26551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26552 if (obj0) {
26553 ecode1 = SWIG_AsVal_int(obj0, &val1);
26554 if (!SWIG_IsOK(ecode1)) {
26555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26556 }
26557 arg1 = static_cast< int >(val1);
26558 }
26559 if (obj1) {
26560 ecode2 = SWIG_AsVal_int(obj1, &val2);
26561 if (!SWIG_IsOK(ecode2)) {
26562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26563 }
26564 arg2 = static_cast< wxEventType >(val2);
26565 }
26566 {
26567 PyThreadState* __tstate = wxPyBeginAllowThreads();
26568 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 PyObject *resultobj = 0;
26581 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26582 void *argp1 = 0 ;
26583 int res1 = 0 ;
26584 PyObject *swig_obj[1] ;
26585
26586 if (!args) SWIG_fail;
26587 swig_obj[0] = args;
26588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26589 if (!SWIG_IsOK(res1)) {
26590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26591 }
26592 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26593 {
26594 PyThreadState* __tstate = wxPyBeginAllowThreads();
26595 delete arg1;
26596
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_Py_Void();
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26608 PyObject *resultobj = 0;
26609 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26610 PyObject *arg2 = (PyObject *) 0 ;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 PyObject * obj0 = 0 ;
26614 PyObject * obj1 = 0 ;
26615 char * kwnames[] = {
26616 (char *) "self",(char *) "self", NULL
26617 };
26618
26619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26621 if (!SWIG_IsOK(res1)) {
26622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26623 }
26624 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26625 arg2 = obj1;
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetSelf(arg2);
26629 wxPyEndAllowThreads(__tstate);
26630 if (PyErr_Occurred()) SWIG_fail;
26631 }
26632 resultobj = SWIG_Py_Void();
26633 return resultobj;
26634 fail:
26635 return NULL;
26636 }
26637
26638
26639 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26640 PyObject *resultobj = 0;
26641 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26642 PyObject *result = 0 ;
26643 void *argp1 = 0 ;
26644 int res1 = 0 ;
26645 PyObject *swig_obj[1] ;
26646
26647 if (!args) SWIG_fail;
26648 swig_obj[0] = args;
26649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26650 if (!SWIG_IsOK(res1)) {
26651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26652 }
26653 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26654 {
26655 PyThreadState* __tstate = wxPyBeginAllowThreads();
26656 result = (PyObject *)(arg1)->GetSelf();
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 resultobj = result;
26661 return resultobj;
26662 fail:
26663 return NULL;
26664 }
26665
26666
26667 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26668 PyObject *obj;
26669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26670 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26671 return SWIG_Py_Void();
26672 }
26673
26674 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26675 return SWIG_Python_InitShadowInstance(args);
26676 }
26677
26678 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26679 PyObject *resultobj = 0;
26680 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26681 int arg2 = (int) 0 ;
26682 wxPyCommandEvent *result = 0 ;
26683 int val1 ;
26684 int ecode1 = 0 ;
26685 int val2 ;
26686 int ecode2 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 PyObject * obj1 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "eventType",(char *) "id", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26694 if (obj0) {
26695 ecode1 = SWIG_AsVal_int(obj0, &val1);
26696 if (!SWIG_IsOK(ecode1)) {
26697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26698 }
26699 arg1 = static_cast< wxEventType >(val1);
26700 }
26701 if (obj1) {
26702 ecode2 = SWIG_AsVal_int(obj1, &val2);
26703 if (!SWIG_IsOK(ecode2)) {
26704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26705 }
26706 arg2 = static_cast< int >(val2);
26707 }
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26711 wxPyEndAllowThreads(__tstate);
26712 if (PyErr_Occurred()) SWIG_fail;
26713 }
26714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26715 return resultobj;
26716 fail:
26717 return NULL;
26718 }
26719
26720
26721 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26722 PyObject *resultobj = 0;
26723 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26724 void *argp1 = 0 ;
26725 int res1 = 0 ;
26726 PyObject *swig_obj[1] ;
26727
26728 if (!args) SWIG_fail;
26729 swig_obj[0] = args;
26730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26731 if (!SWIG_IsOK(res1)) {
26732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26733 }
26734 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 delete arg1;
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 resultobj = SWIG_Py_Void();
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = 0;
26751 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26752 PyObject *arg2 = (PyObject *) 0 ;
26753 void *argp1 = 0 ;
26754 int res1 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "self", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26765 }
26766 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26767 arg2 = obj1;
26768 {
26769 PyThreadState* __tstate = wxPyBeginAllowThreads();
26770 (arg1)->SetSelf(arg2);
26771 wxPyEndAllowThreads(__tstate);
26772 if (PyErr_Occurred()) SWIG_fail;
26773 }
26774 resultobj = SWIG_Py_Void();
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26784 PyObject *result = 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 PyObject *swig_obj[1] ;
26788
26789 if (!args) SWIG_fail;
26790 swig_obj[0] = args;
26791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26792 if (!SWIG_IsOK(res1)) {
26793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26794 }
26795 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 result = (PyObject *)(arg1)->GetSelf();
26799 wxPyEndAllowThreads(__tstate);
26800 if (PyErr_Occurred()) SWIG_fail;
26801 }
26802 resultobj = result;
26803 return resultobj;
26804 fail:
26805 return NULL;
26806 }
26807
26808
26809 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26810 PyObject *obj;
26811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26812 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26813 return SWIG_Py_Void();
26814 }
26815
26816 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26817 return SWIG_Python_InitShadowInstance(args);
26818 }
26819
26820 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = 0;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 wxDateTime *arg2 = 0 ;
26824 wxEventType arg3 ;
26825 wxDateEvent *result = 0 ;
26826 void *argp1 = 0 ;
26827 int res1 = 0 ;
26828 void *argp2 = 0 ;
26829 int res2 = 0 ;
26830 int val3 ;
26831 int ecode3 = 0 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 PyObject * obj2 = 0 ;
26835 char * kwnames[] = {
26836 (char *) "win",(char *) "dt",(char *) "type", NULL
26837 };
26838
26839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26841 if (!SWIG_IsOK(res1)) {
26842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26843 }
26844 arg1 = reinterpret_cast< wxWindow * >(argp1);
26845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26846 if (!SWIG_IsOK(res2)) {
26847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26848 }
26849 if (!argp2) {
26850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26851 }
26852 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26853 ecode3 = SWIG_AsVal_int(obj2, &val3);
26854 if (!SWIG_IsOK(ecode3)) {
26855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26856 }
26857 arg3 = static_cast< wxEventType >(val3);
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26874 wxDateTime *result = 0 ;
26875 void *argp1 = 0 ;
26876 int res1 = 0 ;
26877 PyObject *swig_obj[1] ;
26878
26879 if (!args) SWIG_fail;
26880 swig_obj[0] = args;
26881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 {
26889 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26890 result = (wxDateTime *) &_result_ref;
26891 }
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = 0;
26904 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26905 wxDateTime *arg2 = 0 ;
26906 void *argp1 = 0 ;
26907 int res1 = 0 ;
26908 void *argp2 = 0 ;
26909 int res2 = 0 ;
26910 PyObject * obj0 = 0 ;
26911 PyObject * obj1 = 0 ;
26912 char * kwnames[] = {
26913 (char *) "self",(char *) "date", NULL
26914 };
26915
26916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26920 }
26921 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26922 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26923 if (!SWIG_IsOK(res2)) {
26924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26925 }
26926 if (!argp2) {
26927 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26928 }
26929 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 (arg1)->SetDate((wxDateTime const &)*arg2);
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_Py_Void();
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26944 PyObject *obj;
26945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26946 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26947 return SWIG_Py_Void();
26948 }
26949
26950 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26951 return SWIG_Python_InitShadowInstance(args);
26952 }
26953
26954 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26955 PyObject *resultobj = 0;
26956 wxPyApp *result = 0 ;
26957
26958 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (wxPyApp *)new_wxPyApp();
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26973 PyObject *resultobj = 0;
26974 wxPyApp *arg1 = (wxPyApp *) 0 ;
26975 void *argp1 = 0 ;
26976 int res1 = 0 ;
26977 PyObject *swig_obj[1] ;
26978
26979 if (!args) SWIG_fail;
26980 swig_obj[0] = args;
26981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26982 if (!SWIG_IsOK(res1)) {
26983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26984 }
26985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26986 {
26987 PyThreadState* __tstate = wxPyBeginAllowThreads();
26988 delete arg1;
26989
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 resultobj = SWIG_Py_Void();
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27001 PyObject *resultobj = 0;
27002 wxPyApp *arg1 = (wxPyApp *) 0 ;
27003 PyObject *arg2 = (PyObject *) 0 ;
27004 PyObject *arg3 = (PyObject *) 0 ;
27005 bool arg4 ;
27006 void *argp1 = 0 ;
27007 int res1 = 0 ;
27008 bool val4 ;
27009 int ecode4 = 0 ;
27010 PyObject * obj0 = 0 ;
27011 PyObject * obj1 = 0 ;
27012 PyObject * obj2 = 0 ;
27013 PyObject * obj3 = 0 ;
27014 char * kwnames[] = {
27015 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27016 };
27017
27018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27022 }
27023 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27024 arg2 = obj1;
27025 arg3 = obj2;
27026 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27027 if (!SWIG_IsOK(ecode4)) {
27028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27029 }
27030 arg4 = static_cast< bool >(val4);
27031 {
27032 PyThreadState* __tstate = wxPyBeginAllowThreads();
27033 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 resultobj = SWIG_Py_Void();
27038 return resultobj;
27039 fail:
27040 return NULL;
27041 }
27042
27043
27044 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 PyObject *resultobj = 0;
27046 wxPyApp *arg1 = (wxPyApp *) 0 ;
27047 wxString result;
27048 void *argp1 = 0 ;
27049 int res1 = 0 ;
27050 PyObject *swig_obj[1] ;
27051
27052 if (!args) SWIG_fail;
27053 swig_obj[0] = args;
27054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27055 if (!SWIG_IsOK(res1)) {
27056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27057 }
27058 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27059 {
27060 PyThreadState* __tstate = wxPyBeginAllowThreads();
27061 result = ((wxPyApp const *)arg1)->GetAppName();
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 {
27066 #if wxUSE_UNICODE
27067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27068 #else
27069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27070 #endif
27071 }
27072 return resultobj;
27073 fail:
27074 return NULL;
27075 }
27076
27077
27078 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27079 PyObject *resultobj = 0;
27080 wxPyApp *arg1 = (wxPyApp *) 0 ;
27081 wxString *arg2 = 0 ;
27082 void *argp1 = 0 ;
27083 int res1 = 0 ;
27084 bool temp2 = false ;
27085 PyObject * obj0 = 0 ;
27086 PyObject * obj1 = 0 ;
27087 char * kwnames[] = {
27088 (char *) "self",(char *) "name", NULL
27089 };
27090
27091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27093 if (!SWIG_IsOK(res1)) {
27094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27095 }
27096 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27097 {
27098 arg2 = wxString_in_helper(obj1);
27099 if (arg2 == NULL) SWIG_fail;
27100 temp2 = true;
27101 }
27102 {
27103 PyThreadState* __tstate = wxPyBeginAllowThreads();
27104 (arg1)->SetAppName((wxString const &)*arg2);
27105 wxPyEndAllowThreads(__tstate);
27106 if (PyErr_Occurred()) SWIG_fail;
27107 }
27108 resultobj = SWIG_Py_Void();
27109 {
27110 if (temp2)
27111 delete arg2;
27112 }
27113 return resultobj;
27114 fail:
27115 {
27116 if (temp2)
27117 delete arg2;
27118 }
27119 return NULL;
27120 }
27121
27122
27123 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27124 PyObject *resultobj = 0;
27125 wxPyApp *arg1 = (wxPyApp *) 0 ;
27126 wxString result;
27127 void *argp1 = 0 ;
27128 int res1 = 0 ;
27129 PyObject *swig_obj[1] ;
27130
27131 if (!args) SWIG_fail;
27132 swig_obj[0] = args;
27133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27134 if (!SWIG_IsOK(res1)) {
27135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27136 }
27137 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27138 {
27139 PyThreadState* __tstate = wxPyBeginAllowThreads();
27140 result = ((wxPyApp const *)arg1)->GetClassName();
27141 wxPyEndAllowThreads(__tstate);
27142 if (PyErr_Occurred()) SWIG_fail;
27143 }
27144 {
27145 #if wxUSE_UNICODE
27146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27147 #else
27148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27149 #endif
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = 0;
27159 wxPyApp *arg1 = (wxPyApp *) 0 ;
27160 wxString *arg2 = 0 ;
27161 void *argp1 = 0 ;
27162 int res1 = 0 ;
27163 bool temp2 = false ;
27164 PyObject * obj0 = 0 ;
27165 PyObject * obj1 = 0 ;
27166 char * kwnames[] = {
27167 (char *) "self",(char *) "name", NULL
27168 };
27169
27170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27172 if (!SWIG_IsOK(res1)) {
27173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27174 }
27175 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27176 {
27177 arg2 = wxString_in_helper(obj1);
27178 if (arg2 == NULL) SWIG_fail;
27179 temp2 = true;
27180 }
27181 {
27182 PyThreadState* __tstate = wxPyBeginAllowThreads();
27183 (arg1)->SetClassName((wxString const &)*arg2);
27184 wxPyEndAllowThreads(__tstate);
27185 if (PyErr_Occurred()) SWIG_fail;
27186 }
27187 resultobj = SWIG_Py_Void();
27188 {
27189 if (temp2)
27190 delete arg2;
27191 }
27192 return resultobj;
27193 fail:
27194 {
27195 if (temp2)
27196 delete arg2;
27197 }
27198 return NULL;
27199 }
27200
27201
27202 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27203 PyObject *resultobj = 0;
27204 wxPyApp *arg1 = (wxPyApp *) 0 ;
27205 wxString *result = 0 ;
27206 void *argp1 = 0 ;
27207 int res1 = 0 ;
27208 PyObject *swig_obj[1] ;
27209
27210 if (!args) SWIG_fail;
27211 swig_obj[0] = args;
27212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27215 }
27216 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27217 {
27218 PyThreadState* __tstate = wxPyBeginAllowThreads();
27219 {
27220 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27221 result = (wxString *) &_result_ref;
27222 }
27223 wxPyEndAllowThreads(__tstate);
27224 if (PyErr_Occurred()) SWIG_fail;
27225 }
27226 {
27227 #if wxUSE_UNICODE
27228 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27229 #else
27230 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27231 #endif
27232 }
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27240 PyObject *resultobj = 0;
27241 wxPyApp *arg1 = (wxPyApp *) 0 ;
27242 wxString *arg2 = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 bool temp2 = false ;
27246 PyObject * obj0 = 0 ;
27247 PyObject * obj1 = 0 ;
27248 char * kwnames[] = {
27249 (char *) "self",(char *) "name", NULL
27250 };
27251
27252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27256 }
27257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27258 {
27259 arg2 = wxString_in_helper(obj1);
27260 if (arg2 == NULL) SWIG_fail;
27261 temp2 = true;
27262 }
27263 {
27264 PyThreadState* __tstate = wxPyBeginAllowThreads();
27265 (arg1)->SetVendorName((wxString const &)*arg2);
27266 wxPyEndAllowThreads(__tstate);
27267 if (PyErr_Occurred()) SWIG_fail;
27268 }
27269 resultobj = SWIG_Py_Void();
27270 {
27271 if (temp2)
27272 delete arg2;
27273 }
27274 return resultobj;
27275 fail:
27276 {
27277 if (temp2)
27278 delete arg2;
27279 }
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27285 PyObject *resultobj = 0;
27286 wxPyApp *arg1 = (wxPyApp *) 0 ;
27287 wxAppTraits *result = 0 ;
27288 void *argp1 = 0 ;
27289 int res1 = 0 ;
27290 PyObject *swig_obj[1] ;
27291
27292 if (!args) SWIG_fail;
27293 swig_obj[0] = args;
27294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27295 if (!SWIG_IsOK(res1)) {
27296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27297 }
27298 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 result = (wxAppTraits *)(arg1)->GetTraits();
27302 wxPyEndAllowThreads(__tstate);
27303 if (PyErr_Occurred()) SWIG_fail;
27304 }
27305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27313 PyObject *resultobj = 0;
27314 wxPyApp *arg1 = (wxPyApp *) 0 ;
27315 void *argp1 = 0 ;
27316 int res1 = 0 ;
27317 PyObject *swig_obj[1] ;
27318
27319 if (!args) SWIG_fail;
27320 swig_obj[0] = args;
27321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27322 if (!SWIG_IsOK(res1)) {
27323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27324 }
27325 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27326 {
27327 PyThreadState* __tstate = wxPyBeginAllowThreads();
27328 (arg1)->ProcessPendingEvents();
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = SWIG_Py_Void();
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj = 0;
27341 wxPyApp *arg1 = (wxPyApp *) 0 ;
27342 bool arg2 = (bool) false ;
27343 bool result;
27344 void *argp1 = 0 ;
27345 int res1 = 0 ;
27346 bool val2 ;
27347 int ecode2 = 0 ;
27348 PyObject * obj0 = 0 ;
27349 PyObject * obj1 = 0 ;
27350 char * kwnames[] = {
27351 (char *) "self",(char *) "onlyIfNeeded", NULL
27352 };
27353
27354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27356 if (!SWIG_IsOK(res1)) {
27357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27358 }
27359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27360 if (obj1) {
27361 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27362 if (!SWIG_IsOK(ecode2)) {
27363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27364 }
27365 arg2 = static_cast< bool >(val2);
27366 }
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (bool)(arg1)->Yield(arg2);
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPyApp *arg1 = (wxPyApp *) 0 ;
27385 void *argp1 = 0 ;
27386 int res1 = 0 ;
27387 PyObject *swig_obj[1] ;
27388
27389 if (!args) SWIG_fail;
27390 swig_obj[0] = args;
27391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27392 if (!SWIG_IsOK(res1)) {
27393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27394 }
27395 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->WakeUpIdle();
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_Py_Void();
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410 PyObject *resultobj = 0;
27411 bool result;
27412
27413 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27414 {
27415 PyThreadState* __tstate = wxPyBeginAllowThreads();
27416 result = (bool)wxPyApp::IsMainLoopRunning();
27417 wxPyEndAllowThreads(__tstate);
27418 if (PyErr_Occurred()) SWIG_fail;
27419 }
27420 {
27421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27422 }
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27430 PyObject *resultobj = 0;
27431 wxPyApp *arg1 = (wxPyApp *) 0 ;
27432 int result;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 PyObject *swig_obj[1] ;
27436
27437 if (!args) SWIG_fail;
27438 swig_obj[0] = args;
27439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27440 if (!SWIG_IsOK(res1)) {
27441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27442 }
27443 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27444 {
27445 PyThreadState* __tstate = wxPyBeginAllowThreads();
27446 result = (int)(arg1)->MainLoop();
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = SWIG_From_int(static_cast< int >(result));
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27458 PyObject *resultobj = 0;
27459 wxPyApp *arg1 = (wxPyApp *) 0 ;
27460 void *argp1 = 0 ;
27461 int res1 = 0 ;
27462 PyObject *swig_obj[1] ;
27463
27464 if (!args) SWIG_fail;
27465 swig_obj[0] = args;
27466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27467 if (!SWIG_IsOK(res1)) {
27468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27469 }
27470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 (arg1)->Exit();
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 resultobj = SWIG_Py_Void();
27478 return resultobj;
27479 fail:
27480 return NULL;
27481 }
27482
27483
27484 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27485 PyObject *resultobj = 0;
27486 wxPyApp *arg1 = (wxPyApp *) 0 ;
27487 void *argp1 = 0 ;
27488 int res1 = 0 ;
27489 PyObject *swig_obj[1] ;
27490
27491 if (!args) SWIG_fail;
27492 swig_obj[0] = args;
27493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27494 if (!SWIG_IsOK(res1)) {
27495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27496 }
27497 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->ExitMainLoop();
27501 wxPyEndAllowThreads(__tstate);
27502 if (PyErr_Occurred()) SWIG_fail;
27503 }
27504 resultobj = SWIG_Py_Void();
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27512 PyObject *resultobj = 0;
27513 wxPyApp *arg1 = (wxPyApp *) 0 ;
27514 bool result;
27515 void *argp1 = 0 ;
27516 int res1 = 0 ;
27517 PyObject *swig_obj[1] ;
27518
27519 if (!args) SWIG_fail;
27520 swig_obj[0] = args;
27521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27522 if (!SWIG_IsOK(res1)) {
27523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27524 }
27525 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27526 {
27527 PyThreadState* __tstate = wxPyBeginAllowThreads();
27528 result = (bool)(arg1)->Pending();
27529 wxPyEndAllowThreads(__tstate);
27530 if (PyErr_Occurred()) SWIG_fail;
27531 }
27532 {
27533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27534 }
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27542 PyObject *resultobj = 0;
27543 wxPyApp *arg1 = (wxPyApp *) 0 ;
27544 bool result;
27545 void *argp1 = 0 ;
27546 int res1 = 0 ;
27547 PyObject *swig_obj[1] ;
27548
27549 if (!args) SWIG_fail;
27550 swig_obj[0] = args;
27551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27552 if (!SWIG_IsOK(res1)) {
27553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27554 }
27555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (bool)(arg1)->Dispatch();
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 {
27563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27564 }
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27572 PyObject *resultobj = 0;
27573 wxPyApp *arg1 = (wxPyApp *) 0 ;
27574 bool result;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 PyObject *swig_obj[1] ;
27578
27579 if (!args) SWIG_fail;
27580 swig_obj[0] = args;
27581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27582 if (!SWIG_IsOK(res1)) {
27583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27584 }
27585 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 result = (bool)(arg1)->ProcessIdle();
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 {
27593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27594 }
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27602 PyObject *resultobj = 0;
27603 wxPyApp *arg1 = (wxPyApp *) 0 ;
27604 wxWindow *arg2 = (wxWindow *) 0 ;
27605 wxIdleEvent *arg3 = 0 ;
27606 bool result;
27607 void *argp1 = 0 ;
27608 int res1 = 0 ;
27609 void *argp2 = 0 ;
27610 int res2 = 0 ;
27611 void *argp3 = 0 ;
27612 int res3 = 0 ;
27613 PyObject * obj0 = 0 ;
27614 PyObject * obj1 = 0 ;
27615 PyObject * obj2 = 0 ;
27616 char * kwnames[] = {
27617 (char *) "self",(char *) "win",(char *) "event", NULL
27618 };
27619
27620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27624 }
27625 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27627 if (!SWIG_IsOK(res2)) {
27628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27629 }
27630 arg2 = reinterpret_cast< wxWindow * >(argp2);
27631 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27632 if (!SWIG_IsOK(res3)) {
27633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27634 }
27635 if (!argp3) {
27636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27637 }
27638 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 {
27646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27647 }
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxPyApp *arg1 = (wxPyApp *) 0 ;
27657 bool result;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 PyObject *swig_obj[1] ;
27661
27662 if (!args) SWIG_fail;
27663 swig_obj[0] = args;
27664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27665 if (!SWIG_IsOK(res1)) {
27666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27667 }
27668 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 result = (bool)((wxPyApp const *)arg1)->IsActive();
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 {
27676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27677 }
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27685 PyObject *resultobj = 0;
27686 wxPyApp *arg1 = (wxPyApp *) 0 ;
27687 wxWindow *arg2 = (wxWindow *) 0 ;
27688 void *argp1 = 0 ;
27689 int res1 = 0 ;
27690 void *argp2 = 0 ;
27691 int res2 = 0 ;
27692 PyObject * obj0 = 0 ;
27693 PyObject * obj1 = 0 ;
27694 char * kwnames[] = {
27695 (char *) "self",(char *) "win", NULL
27696 };
27697
27698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27702 }
27703 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27705 if (!SWIG_IsOK(res2)) {
27706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27707 }
27708 arg2 = reinterpret_cast< wxWindow * >(argp2);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 (arg1)->SetTopWindow(arg2);
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = SWIG_Py_Void();
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *resultobj = 0;
27724 wxPyApp *arg1 = (wxPyApp *) 0 ;
27725 wxWindow *result = 0 ;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 PyObject *swig_obj[1] ;
27729
27730 if (!args) SWIG_fail;
27731 swig_obj[0] = args;
27732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27735 }
27736 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = wxPyMake_wxObject(result, (bool)0);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27753 PyObject *resultobj = 0;
27754 wxPyApp *arg1 = (wxPyApp *) 0 ;
27755 bool arg2 ;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 bool val2 ;
27759 int ecode2 = 0 ;
27760 PyObject * obj0 = 0 ;
27761 PyObject * obj1 = 0 ;
27762 char * kwnames[] = {
27763 (char *) "self",(char *) "flag", NULL
27764 };
27765
27766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27768 if (!SWIG_IsOK(res1)) {
27769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27770 }
27771 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27773 if (!SWIG_IsOK(ecode2)) {
27774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27775 }
27776 arg2 = static_cast< bool >(val2);
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 (arg1)->SetExitOnFrameDelete(arg2);
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 resultobj = SWIG_Py_Void();
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27791 PyObject *resultobj = 0;
27792 wxPyApp *arg1 = (wxPyApp *) 0 ;
27793 bool result;
27794 void *argp1 = 0 ;
27795 int res1 = 0 ;
27796 PyObject *swig_obj[1] ;
27797
27798 if (!args) SWIG_fail;
27799 swig_obj[0] = args;
27800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27801 if (!SWIG_IsOK(res1)) {
27802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27803 }
27804 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 {
27812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27813 }
27814 return resultobj;
27815 fail:
27816 return NULL;
27817 }
27818
27819
27820 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27821 PyObject *resultobj = 0;
27822 wxPyApp *arg1 = (wxPyApp *) 0 ;
27823 bool arg2 ;
27824 void *argp1 = 0 ;
27825 int res1 = 0 ;
27826 bool val2 ;
27827 int ecode2 = 0 ;
27828 PyObject * obj0 = 0 ;
27829 PyObject * obj1 = 0 ;
27830 char * kwnames[] = {
27831 (char *) "self",(char *) "flag", NULL
27832 };
27833
27834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27836 if (!SWIG_IsOK(res1)) {
27837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27838 }
27839 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27841 if (!SWIG_IsOK(ecode2)) {
27842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27843 }
27844 arg2 = static_cast< bool >(val2);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 (arg1)->SetUseBestVisual(arg2);
27848 wxPyEndAllowThreads(__tstate);
27849 if (PyErr_Occurred()) SWIG_fail;
27850 }
27851 resultobj = SWIG_Py_Void();
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 PyObject *resultobj = 0;
27860 wxPyApp *arg1 = (wxPyApp *) 0 ;
27861 bool result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 PyObject *swig_obj[1] ;
27865
27866 if (!args) SWIG_fail;
27867 swig_obj[0] = args;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27871 }
27872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj = 0;
27890 wxPyApp *arg1 = (wxPyApp *) 0 ;
27891 int arg2 ;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 int val2 ;
27895 int ecode2 = 0 ;
27896 PyObject * obj0 = 0 ;
27897 PyObject * obj1 = 0 ;
27898 char * kwnames[] = {
27899 (char *) "self",(char *) "mode", NULL
27900 };
27901
27902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27904 if (!SWIG_IsOK(res1)) {
27905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27906 }
27907 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27908 ecode2 = SWIG_AsVal_int(obj1, &val2);
27909 if (!SWIG_IsOK(ecode2)) {
27910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27911 }
27912 arg2 = static_cast< int >(val2);
27913 {
27914 PyThreadState* __tstate = wxPyBeginAllowThreads();
27915 (arg1)->SetPrintMode(arg2);
27916 wxPyEndAllowThreads(__tstate);
27917 if (PyErr_Occurred()) SWIG_fail;
27918 }
27919 resultobj = SWIG_Py_Void();
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27927 PyObject *resultobj = 0;
27928 wxPyApp *arg1 = (wxPyApp *) 0 ;
27929 int result;
27930 void *argp1 = 0 ;
27931 int res1 = 0 ;
27932 PyObject *swig_obj[1] ;
27933
27934 if (!args) SWIG_fail;
27935 swig_obj[0] = args;
27936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27939 }
27940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_From_int(static_cast< int >(result));
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27955 PyObject *resultobj = 0;
27956 wxPyApp *arg1 = (wxPyApp *) 0 ;
27957 int arg2 ;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 int val2 ;
27961 int ecode2 = 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 char * kwnames[] = {
27965 (char *) "self",(char *) "mode", NULL
27966 };
27967
27968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27970 if (!SWIG_IsOK(res1)) {
27971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27972 }
27973 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27974 ecode2 = SWIG_AsVal_int(obj1, &val2);
27975 if (!SWIG_IsOK(ecode2)) {
27976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27977 }
27978 arg2 = static_cast< int >(val2);
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 (arg1)->SetAssertMode(arg2);
27982 wxPyEndAllowThreads(__tstate);
27983 if (PyErr_Occurred()) SWIG_fail;
27984 }
27985 resultobj = SWIG_Py_Void();
27986 return resultobj;
27987 fail:
27988 return NULL;
27989 }
27990
27991
27992 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27993 PyObject *resultobj = 0;
27994 wxPyApp *arg1 = (wxPyApp *) 0 ;
27995 int result;
27996 void *argp1 = 0 ;
27997 int res1 = 0 ;
27998 PyObject *swig_obj[1] ;
27999
28000 if (!args) SWIG_fail;
28001 swig_obj[0] = args;
28002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28003 if (!SWIG_IsOK(res1)) {
28004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28005 }
28006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (int)(arg1)->GetAssertMode();
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_From_int(static_cast< int >(result));
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28021 PyObject *resultobj = 0;
28022 bool result;
28023
28024 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28025 {
28026 PyThreadState* __tstate = wxPyBeginAllowThreads();
28027 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28028 wxPyEndAllowThreads(__tstate);
28029 if (PyErr_Occurred()) SWIG_fail;
28030 }
28031 {
28032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28033 }
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28041 PyObject *resultobj = 0;
28042 long result;
28043
28044 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 result = (long)wxPyApp::GetMacAboutMenuItemId();
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_From_long(static_cast< long >(result));
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28059 PyObject *resultobj = 0;
28060 long result;
28061
28062 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28063 {
28064 PyThreadState* __tstate = wxPyBeginAllowThreads();
28065 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28066 wxPyEndAllowThreads(__tstate);
28067 if (PyErr_Occurred()) SWIG_fail;
28068 }
28069 resultobj = SWIG_From_long(static_cast< long >(result));
28070 return resultobj;
28071 fail:
28072 return NULL;
28073 }
28074
28075
28076 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28077 PyObject *resultobj = 0;
28078 long result;
28079
28080 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 result = (long)wxPyApp::GetMacExitMenuItemId();
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_From_long(static_cast< long >(result));
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 wxString result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = wxPyApp::GetMacHelpMenuTitleName();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 {
28106 #if wxUSE_UNICODE
28107 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28108 #else
28109 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28110 #endif
28111 }
28112 return resultobj;
28113 fail:
28114 return NULL;
28115 }
28116
28117
28118 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28119 PyObject *resultobj = 0;
28120 bool arg1 ;
28121 bool val1 ;
28122 int ecode1 = 0 ;
28123 PyObject * obj0 = 0 ;
28124 char * kwnames[] = {
28125 (char *) "val", NULL
28126 };
28127
28128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28129 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28130 if (!SWIG_IsOK(ecode1)) {
28131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28132 }
28133 arg1 = static_cast< bool >(val1);
28134 {
28135 PyThreadState* __tstate = wxPyBeginAllowThreads();
28136 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28137 wxPyEndAllowThreads(__tstate);
28138 if (PyErr_Occurred()) SWIG_fail;
28139 }
28140 resultobj = SWIG_Py_Void();
28141 return resultobj;
28142 fail:
28143 return NULL;
28144 }
28145
28146
28147 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj = 0;
28149 long arg1 ;
28150 long val1 ;
28151 int ecode1 = 0 ;
28152 PyObject * obj0 = 0 ;
28153 char * kwnames[] = {
28154 (char *) "val", NULL
28155 };
28156
28157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28158 ecode1 = SWIG_AsVal_long(obj0, &val1);
28159 if (!SWIG_IsOK(ecode1)) {
28160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28161 }
28162 arg1 = static_cast< long >(val1);
28163 {
28164 PyThreadState* __tstate = wxPyBeginAllowThreads();
28165 wxPyApp::SetMacAboutMenuItemId(arg1);
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 resultobj = SWIG_Py_Void();
28170 return resultobj;
28171 fail:
28172 return NULL;
28173 }
28174
28175
28176 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28177 PyObject *resultobj = 0;
28178 long arg1 ;
28179 long val1 ;
28180 int ecode1 = 0 ;
28181 PyObject * obj0 = 0 ;
28182 char * kwnames[] = {
28183 (char *) "val", NULL
28184 };
28185
28186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28187 ecode1 = SWIG_AsVal_long(obj0, &val1);
28188 if (!SWIG_IsOK(ecode1)) {
28189 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28190 }
28191 arg1 = static_cast< long >(val1);
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 resultobj = SWIG_Py_Void();
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28206 PyObject *resultobj = 0;
28207 long arg1 ;
28208 long val1 ;
28209 int ecode1 = 0 ;
28210 PyObject * obj0 = 0 ;
28211 char * kwnames[] = {
28212 (char *) "val", NULL
28213 };
28214
28215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28216 ecode1 = SWIG_AsVal_long(obj0, &val1);
28217 if (!SWIG_IsOK(ecode1)) {
28218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28219 }
28220 arg1 = static_cast< long >(val1);
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 wxPyApp::SetMacExitMenuItemId(arg1);
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 resultobj = SWIG_Py_Void();
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28235 PyObject *resultobj = 0;
28236 wxString *arg1 = 0 ;
28237 bool temp1 = false ;
28238 PyObject * obj0 = 0 ;
28239 char * kwnames[] = {
28240 (char *) "val", NULL
28241 };
28242
28243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28244 {
28245 arg1 = wxString_in_helper(obj0);
28246 if (arg1 == NULL) SWIG_fail;
28247 temp1 = true;
28248 }
28249 {
28250 PyThreadState* __tstate = wxPyBeginAllowThreads();
28251 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 resultobj = SWIG_Py_Void();
28256 {
28257 if (temp1)
28258 delete arg1;
28259 }
28260 return resultobj;
28261 fail:
28262 {
28263 if (temp1)
28264 delete arg1;
28265 }
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 wxPyApp *arg1 = (wxPyApp *) 0 ;
28273 void *argp1 = 0 ;
28274 int res1 = 0 ;
28275 PyObject *swig_obj[1] ;
28276
28277 if (!args) SWIG_fail;
28278 swig_obj[0] = args;
28279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28280 if (!SWIG_IsOK(res1)) {
28281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28282 }
28283 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28284 {
28285 PyThreadState* __tstate = wxPyBeginAllowThreads();
28286 (arg1)->_BootstrapApp();
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_Py_Void();
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28298 PyObject *resultobj = 0;
28299 int result;
28300
28301 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28302 {
28303 PyThreadState* __tstate = wxPyBeginAllowThreads();
28304 result = (int)wxPyApp_GetComCtl32Version();
28305 wxPyEndAllowThreads(__tstate);
28306 if (PyErr_Occurred()) SWIG_fail;
28307 }
28308 resultobj = SWIG_From_int(static_cast< int >(result));
28309 return resultobj;
28310 fail:
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28316 PyObject *obj;
28317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28318 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28319 return SWIG_Py_Void();
28320 }
28321
28322 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 return SWIG_Python_InitShadowInstance(args);
28324 }
28325
28326 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28327 PyObject *resultobj = 0;
28328
28329 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 wxExit();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_Py_Void();
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 bool result;
28346
28347 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28348 {
28349 PyThreadState* __tstate = wxPyBeginAllowThreads();
28350 result = (bool)wxYield();
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28364 PyObject *resultobj = 0;
28365 bool result;
28366
28367 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = (bool)wxYieldIfNeeded();
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 {
28375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28376 }
28377 return resultobj;
28378 fail:
28379 return NULL;
28380 }
28381
28382
28383 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28384 PyObject *resultobj = 0;
28385 wxWindow *arg1 = (wxWindow *) NULL ;
28386 bool arg2 = (bool) false ;
28387 bool result;
28388 void *argp1 = 0 ;
28389 int res1 = 0 ;
28390 bool val2 ;
28391 int ecode2 = 0 ;
28392 PyObject * obj0 = 0 ;
28393 PyObject * obj1 = 0 ;
28394 char * kwnames[] = {
28395 (char *) "win",(char *) "onlyIfNeeded", NULL
28396 };
28397
28398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28399 if (obj0) {
28400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28403 }
28404 arg1 = reinterpret_cast< wxWindow * >(argp1);
28405 }
28406 if (obj1) {
28407 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28408 if (!SWIG_IsOK(ecode2)) {
28409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28410 }
28411 arg2 = static_cast< bool >(val2);
28412 }
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)wxSafeYield(arg1,arg2);
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 PyObject *resultobj = 0;
28430
28431 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 wxWakeUpIdle();
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 resultobj = SWIG_Py_Void();
28439 return resultobj;
28440 fail:
28441 return NULL;
28442 }
28443
28444
28445 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28446 PyObject *resultobj = 0;
28447 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28448 wxEvent *arg2 = 0 ;
28449 void *argp1 = 0 ;
28450 int res1 = 0 ;
28451 void *argp2 = 0 ;
28452 int res2 = 0 ;
28453 PyObject * obj0 = 0 ;
28454 PyObject * obj1 = 0 ;
28455 char * kwnames[] = {
28456 (char *) "dest",(char *) "event", NULL
28457 };
28458
28459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28461 if (!SWIG_IsOK(res1)) {
28462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28463 }
28464 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28466 if (!SWIG_IsOK(res2)) {
28467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28468 }
28469 if (!argp2) {
28470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28471 }
28472 arg2 = reinterpret_cast< wxEvent * >(argp2);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 wxPostEvent(arg1,*arg2);
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 resultobj = SWIG_Py_Void();
28480 return resultobj;
28481 fail:
28482 return NULL;
28483 }
28484
28485
28486 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 PyObject *resultobj = 0;
28488
28489 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 wxApp_CleanUp();
28493 wxPyEndAllowThreads(__tstate);
28494 if (PyErr_Occurred()) SWIG_fail;
28495 }
28496 resultobj = SWIG_Py_Void();
28497 return resultobj;
28498 fail:
28499 return NULL;
28500 }
28501
28502
28503 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28504 PyObject *resultobj = 0;
28505 wxPyApp *result = 0 ;
28506
28507 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28508 {
28509 PyThreadState* __tstate = wxPyBeginAllowThreads();
28510 result = (wxPyApp *)wxPyGetApp();
28511 wxPyEndAllowThreads(__tstate);
28512 if (PyErr_Occurred()) SWIG_fail;
28513 }
28514 {
28515 resultobj = wxPyMake_wxObject(result, 0);
28516 }
28517 return resultobj;
28518 fail:
28519 return NULL;
28520 }
28521
28522
28523 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28524 PyObject *resultobj = 0;
28525 char *arg1 = (char *) 0 ;
28526 int res1 ;
28527 char *buf1 = 0 ;
28528 int alloc1 = 0 ;
28529 PyObject * obj0 = 0 ;
28530 char * kwnames[] = {
28531 (char *) "encoding", NULL
28532 };
28533
28534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28535 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28536 if (!SWIG_IsOK(res1)) {
28537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28538 }
28539 arg1 = buf1;
28540 {
28541 PyThreadState* __tstate = wxPyBeginAllowThreads();
28542 wxSetDefaultPyEncoding((char const *)arg1);
28543 wxPyEndAllowThreads(__tstate);
28544 if (PyErr_Occurred()) SWIG_fail;
28545 }
28546 resultobj = SWIG_Py_Void();
28547 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28548 return resultobj;
28549 fail:
28550 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28551 return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28556 PyObject *resultobj = 0;
28557 char *result = 0 ;
28558
28559 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (char *)wxGetDefaultPyEncoding();
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_FromCharPtr(result);
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxEventLoop *result = 0 ;
28576
28577 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = (wxEventLoop *)new wxEventLoop();
28581 wxPyEndAllowThreads(__tstate);
28582 if (PyErr_Occurred()) SWIG_fail;
28583 }
28584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28585 return resultobj;
28586 fail:
28587 return NULL;
28588 }
28589
28590
28591 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28592 PyObject *resultobj = 0;
28593 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28603 }
28604 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 delete arg1;
28608
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 resultobj = SWIG_Py_Void();
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28620 PyObject *resultobj = 0;
28621 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28622 int result;
28623 void *argp1 = 0 ;
28624 int res1 = 0 ;
28625 PyObject *swig_obj[1] ;
28626
28627 if (!args) SWIG_fail;
28628 swig_obj[0] = args;
28629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28630 if (!SWIG_IsOK(res1)) {
28631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28632 }
28633 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (int)(arg1)->Run();
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 resultobj = SWIG_From_int(static_cast< int >(result));
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj = 0;
28649 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28650 int arg2 = (int) 0 ;
28651 void *argp1 = 0 ;
28652 int res1 = 0 ;
28653 int val2 ;
28654 int ecode2 = 0 ;
28655 PyObject * obj0 = 0 ;
28656 PyObject * obj1 = 0 ;
28657 char * kwnames[] = {
28658 (char *) "self",(char *) "rc", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28665 }
28666 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28667 if (obj1) {
28668 ecode2 = SWIG_AsVal_int(obj1, &val2);
28669 if (!SWIG_IsOK(ecode2)) {
28670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28671 }
28672 arg2 = static_cast< int >(val2);
28673 }
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 (arg1)->Exit(arg2);
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_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28688 PyObject *resultobj = 0;
28689 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28690 bool result;
28691 void *argp1 = 0 ;
28692 int res1 = 0 ;
28693 PyObject *swig_obj[1] ;
28694
28695 if (!args) SWIG_fail;
28696 swig_obj[0] = args;
28697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28698 if (!SWIG_IsOK(res1)) {
28699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28700 }
28701 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28702 {
28703 PyThreadState* __tstate = wxPyBeginAllowThreads();
28704 result = (bool)((wxEventLoop const *)arg1)->Pending();
28705 wxPyEndAllowThreads(__tstate);
28706 if (PyErr_Occurred()) SWIG_fail;
28707 }
28708 {
28709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28710 }
28711 return resultobj;
28712 fail:
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28718 PyObject *resultobj = 0;
28719 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28720 bool result;
28721 void *argp1 = 0 ;
28722 int res1 = 0 ;
28723 PyObject *swig_obj[1] ;
28724
28725 if (!args) SWIG_fail;
28726 swig_obj[0] = args;
28727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28728 if (!SWIG_IsOK(res1)) {
28729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28730 }
28731 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 result = (bool)(arg1)->Dispatch();
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 {
28739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28740 }
28741 return resultobj;
28742 fail:
28743 return NULL;
28744 }
28745
28746
28747 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28748 PyObject *resultobj = 0;
28749 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28750 bool result;
28751 void *argp1 = 0 ;
28752 int res1 = 0 ;
28753 PyObject *swig_obj[1] ;
28754
28755 if (!args) SWIG_fail;
28756 swig_obj[0] = args;
28757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28760 }
28761 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28762 {
28763 PyThreadState* __tstate = wxPyBeginAllowThreads();
28764 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28765 wxPyEndAllowThreads(__tstate);
28766 if (PyErr_Occurred()) SWIG_fail;
28767 }
28768 {
28769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28770 }
28771 return resultobj;
28772 fail:
28773 return NULL;
28774 }
28775
28776
28777 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28778 PyObject *resultobj = 0;
28779 wxEventLoop *result = 0 ;
28780
28781 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (wxEventLoop *)wxEventLoop::GetActive();
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj = 0;
28797 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28798 void *argp1 = 0 ;
28799 int res1 = 0 ;
28800 PyObject * obj0 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "loop", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28809 }
28810 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 wxEventLoop::SetActive(arg1);
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 resultobj = SWIG_Py_Void();
28818 return resultobj;
28819 fail:
28820 return NULL;
28821 }
28822
28823
28824 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28825 PyObject *obj;
28826 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28827 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28828 return SWIG_Py_Void();
28829 }
28830
28831 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28832 return SWIG_Python_InitShadowInstance(args);
28833 }
28834
28835 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28836 PyObject *resultobj = 0;
28837 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28838 wxEventLoopActivator *result = 0 ;
28839 void *argp1 = 0 ;
28840 int res1 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 char * kwnames[] = {
28843 (char *) "evtLoop", NULL
28844 };
28845
28846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28848 if (!SWIG_IsOK(res1)) {
28849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28850 }
28851 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28852 {
28853 PyThreadState* __tstate = wxPyBeginAllowThreads();
28854 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28866 PyObject *resultobj = 0;
28867 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28868 void *argp1 = 0 ;
28869 int res1 = 0 ;
28870 PyObject *swig_obj[1] ;
28871
28872 if (!args) SWIG_fail;
28873 swig_obj[0] = args;
28874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28875 if (!SWIG_IsOK(res1)) {
28876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28877 }
28878 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 delete arg1;
28882
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 resultobj = SWIG_Py_Void();
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28894 PyObject *obj;
28895 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28896 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28897 return SWIG_Py_Void();
28898 }
28899
28900 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 return SWIG_Python_InitShadowInstance(args);
28902 }
28903
28904 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28905 PyObject *resultobj = 0;
28906 int arg1 = (int) 0 ;
28907 int arg2 = (int) 0 ;
28908 int arg3 = (int) 0 ;
28909 wxAcceleratorEntry *result = 0 ;
28910 int val1 ;
28911 int ecode1 = 0 ;
28912 int val2 ;
28913 int ecode2 = 0 ;
28914 int val3 ;
28915 int ecode3 = 0 ;
28916 PyObject * obj0 = 0 ;
28917 PyObject * obj1 = 0 ;
28918 PyObject * obj2 = 0 ;
28919 char * kwnames[] = {
28920 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28921 };
28922
28923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28924 if (obj0) {
28925 ecode1 = SWIG_AsVal_int(obj0, &val1);
28926 if (!SWIG_IsOK(ecode1)) {
28927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28928 }
28929 arg1 = static_cast< int >(val1);
28930 }
28931 if (obj1) {
28932 ecode2 = SWIG_AsVal_int(obj1, &val2);
28933 if (!SWIG_IsOK(ecode2)) {
28934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28935 }
28936 arg2 = static_cast< int >(val2);
28937 }
28938 if (obj2) {
28939 ecode3 = SWIG_AsVal_int(obj2, &val3);
28940 if (!SWIG_IsOK(ecode3)) {
28941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28942 }
28943 arg3 = static_cast< int >(val3);
28944 }
28945 {
28946 PyThreadState* __tstate = wxPyBeginAllowThreads();
28947 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28948 wxPyEndAllowThreads(__tstate);
28949 if (PyErr_Occurred()) SWIG_fail;
28950 }
28951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28959 PyObject *resultobj = 0;
28960 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28961 void *argp1 = 0 ;
28962 int res1 = 0 ;
28963 PyObject *swig_obj[1] ;
28964
28965 if (!args) SWIG_fail;
28966 swig_obj[0] = args;
28967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28968 if (!SWIG_IsOK(res1)) {
28969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28970 }
28971 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 delete arg1;
28975
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 resultobj = SWIG_Py_Void();
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = 0;
28988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28989 int arg2 ;
28990 int arg3 ;
28991 int arg4 ;
28992 void *argp1 = 0 ;
28993 int res1 = 0 ;
28994 int val2 ;
28995 int ecode2 = 0 ;
28996 int val3 ;
28997 int ecode3 = 0 ;
28998 int val4 ;
28999 int ecode4 = 0 ;
29000 PyObject * obj0 = 0 ;
29001 PyObject * obj1 = 0 ;
29002 PyObject * obj2 = 0 ;
29003 PyObject * obj3 = 0 ;
29004 char * kwnames[] = {
29005 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29006 };
29007
29008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29010 if (!SWIG_IsOK(res1)) {
29011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29012 }
29013 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29014 ecode2 = SWIG_AsVal_int(obj1, &val2);
29015 if (!SWIG_IsOK(ecode2)) {
29016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29017 }
29018 arg2 = static_cast< int >(val2);
29019 ecode3 = SWIG_AsVal_int(obj2, &val3);
29020 if (!SWIG_IsOK(ecode3)) {
29021 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29022 }
29023 arg3 = static_cast< int >(val3);
29024 ecode4 = SWIG_AsVal_int(obj3, &val4);
29025 if (!SWIG_IsOK(ecode4)) {
29026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29027 }
29028 arg4 = static_cast< int >(val4);
29029 {
29030 PyThreadState* __tstate = wxPyBeginAllowThreads();
29031 (arg1)->Set(arg2,arg3,arg4);
29032 wxPyEndAllowThreads(__tstate);
29033 if (PyErr_Occurred()) SWIG_fail;
29034 }
29035 resultobj = SWIG_Py_Void();
29036 return resultobj;
29037 fail:
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *resultobj = 0;
29044 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29045 int result;
29046 void *argp1 = 0 ;
29047 int res1 = 0 ;
29048 PyObject *swig_obj[1] ;
29049
29050 if (!args) SWIG_fail;
29051 swig_obj[0] = args;
29052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29053 if (!SWIG_IsOK(res1)) {
29054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29055 }
29056 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (int)(arg1)->GetFlags();
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_From_int(static_cast< int >(result));
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29073 int result;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29083 }
29084 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (int)(arg1)->GetKeyCode();
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 resultobj = SWIG_From_int(static_cast< int >(result));
29092 return resultobj;
29093 fail:
29094 return NULL;
29095 }
29096
29097
29098 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29099 PyObject *resultobj = 0;
29100 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29101 int result;
29102 void *argp1 = 0 ;
29103 int res1 = 0 ;
29104 PyObject *swig_obj[1] ;
29105
29106 if (!args) SWIG_fail;
29107 swig_obj[0] = args;
29108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29109 if (!SWIG_IsOK(res1)) {
29110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29111 }
29112 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 result = (int)(arg1)->GetCommand();
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_From_int(static_cast< int >(result));
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *obj;
29128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29129 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 int arg1 ;
29140 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29141 wxAcceleratorTable *result = 0 ;
29142 PyObject * obj0 = 0 ;
29143 char * kwnames[] = {
29144 (char *) "n", NULL
29145 };
29146
29147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29148 {
29149 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29150 if (arg2) arg1 = PyList_Size(obj0);
29151 else arg1 = 0;
29152 }
29153 {
29154 PyThreadState* __tstate = wxPyBeginAllowThreads();
29155 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29156 wxPyEndAllowThreads(__tstate);
29157 if (PyErr_Occurred()) SWIG_fail;
29158 }
29159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29160 return resultobj;
29161 fail:
29162 return NULL;
29163 }
29164
29165
29166 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29167 PyObject *resultobj = 0;
29168 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29169 void *argp1 = 0 ;
29170 int res1 = 0 ;
29171 PyObject *swig_obj[1] ;
29172
29173 if (!args) SWIG_fail;
29174 swig_obj[0] = args;
29175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29176 if (!SWIG_IsOK(res1)) {
29177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29178 }
29179 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29180 {
29181 PyThreadState* __tstate = wxPyBeginAllowThreads();
29182 delete arg1;
29183
29184 wxPyEndAllowThreads(__tstate);
29185 if (PyErr_Occurred()) SWIG_fail;
29186 }
29187 resultobj = SWIG_Py_Void();
29188 return resultobj;
29189 fail:
29190 return NULL;
29191 }
29192
29193
29194 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29195 PyObject *resultobj = 0;
29196 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29197 bool result;
29198 void *argp1 = 0 ;
29199 int res1 = 0 ;
29200 PyObject *swig_obj[1] ;
29201
29202 if (!args) SWIG_fail;
29203 swig_obj[0] = args;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29207 }
29208 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 {
29216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29217 }
29218 return resultobj;
29219 fail:
29220 return NULL;
29221 }
29222
29223
29224 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29225 PyObject *obj;
29226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29227 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29228 return SWIG_Py_Void();
29229 }
29230
29231 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 return SWIG_Python_InitShadowInstance(args);
29233 }
29234
29235 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29236 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29237 return 1;
29238 }
29239
29240
29241 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29242 PyObject *pyobj = 0;
29243
29244 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29245 return pyobj;
29246 }
29247
29248
29249 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29250 PyObject *resultobj = 0;
29251 wxString *arg1 = 0 ;
29252 wxAcceleratorEntry *result = 0 ;
29253 bool temp1 = false ;
29254 PyObject * obj0 = 0 ;
29255 char * kwnames[] = {
29256 (char *) "label", NULL
29257 };
29258
29259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29260 {
29261 arg1 = wxString_in_helper(obj0);
29262 if (arg1 == NULL) SWIG_fail;
29263 temp1 = true;
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29272 {
29273 if (temp1)
29274 delete arg1;
29275 }
29276 return resultobj;
29277 fail:
29278 {
29279 if (temp1)
29280 delete arg1;
29281 }
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN int PanelNameStr_set(PyObject *) {
29287 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29288 return 1;
29289 }
29290
29291
29292 SWIGINTERN PyObject *PanelNameStr_get(void) {
29293 PyObject *pyobj = 0;
29294
29295 {
29296 #if wxUSE_UNICODE
29297 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29298 #else
29299 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29300 #endif
29301 }
29302 return pyobj;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29307 PyObject *resultobj = 0;
29308 wxVisualAttributes *result = 0 ;
29309
29310 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 result = (wxVisualAttributes *)new_wxVisualAttributes();
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29318 return resultobj;
29319 fail:
29320 return NULL;
29321 }
29322
29323
29324 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29325 PyObject *resultobj = 0;
29326 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29327 void *argp1 = 0 ;
29328 int res1 = 0 ;
29329 PyObject *swig_obj[1] ;
29330
29331 if (!args) SWIG_fail;
29332 swig_obj[0] = args;
29333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29334 if (!SWIG_IsOK(res1)) {
29335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29336 }
29337 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29338 {
29339 PyThreadState* __tstate = wxPyBeginAllowThreads();
29340 delete_wxVisualAttributes(arg1);
29341
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_Py_Void();
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 PyObject *resultobj = 0;
29354 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29355 wxFont *arg2 = (wxFont *) 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 void *argp2 = 0 ;
29359 int res2 = 0 ;
29360 PyObject *swig_obj[2] ;
29361
29362 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29364 if (!SWIG_IsOK(res1)) {
29365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29366 }
29367 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29368 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29369 if (!SWIG_IsOK(res2)) {
29370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29371 }
29372 arg2 = reinterpret_cast< wxFont * >(argp2);
29373 if (arg1) (arg1)->font = *arg2;
29374
29375 resultobj = SWIG_Py_Void();
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29383 PyObject *resultobj = 0;
29384 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29385 wxFont *result = 0 ;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 PyObject *swig_obj[1] ;
29389
29390 if (!args) SWIG_fail;
29391 swig_obj[0] = args;
29392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29393 if (!SWIG_IsOK(res1)) {
29394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29395 }
29396 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29397 result = (wxFont *)& ((arg1)->font);
29398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29399 return resultobj;
29400 fail:
29401 return NULL;
29402 }
29403
29404
29405 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29406 PyObject *resultobj = 0;
29407 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29408 wxColour *arg2 = (wxColour *) 0 ;
29409 void *argp1 = 0 ;
29410 int res1 = 0 ;
29411 void *argp2 = 0 ;
29412 int res2 = 0 ;
29413 PyObject *swig_obj[2] ;
29414
29415 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29417 if (!SWIG_IsOK(res1)) {
29418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29419 }
29420 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29421 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29422 if (!SWIG_IsOK(res2)) {
29423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29424 }
29425 arg2 = reinterpret_cast< wxColour * >(argp2);
29426 if (arg1) (arg1)->colFg = *arg2;
29427
29428 resultobj = SWIG_Py_Void();
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29436 PyObject *resultobj = 0;
29437 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29438 wxColour *result = 0 ;
29439 void *argp1 = 0 ;
29440 int res1 = 0 ;
29441 PyObject *swig_obj[1] ;
29442
29443 if (!args) SWIG_fail;
29444 swig_obj[0] = args;
29445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29446 if (!SWIG_IsOK(res1)) {
29447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29448 }
29449 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29450 result = (wxColour *)& ((arg1)->colFg);
29451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29461 wxColour *arg2 = (wxColour *) 0 ;
29462 void *argp1 = 0 ;
29463 int res1 = 0 ;
29464 void *argp2 = 0 ;
29465 int res2 = 0 ;
29466 PyObject *swig_obj[2] ;
29467
29468 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29470 if (!SWIG_IsOK(res1)) {
29471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29472 }
29473 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29474 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29475 if (!SWIG_IsOK(res2)) {
29476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29477 }
29478 arg2 = reinterpret_cast< wxColour * >(argp2);
29479 if (arg1) (arg1)->colBg = *arg2;
29480
29481 resultobj = SWIG_Py_Void();
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29489 PyObject *resultobj = 0;
29490 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29491 wxColour *result = 0 ;
29492 void *argp1 = 0 ;
29493 int res1 = 0 ;
29494 PyObject *swig_obj[1] ;
29495
29496 if (!args) SWIG_fail;
29497 swig_obj[0] = args;
29498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29499 if (!SWIG_IsOK(res1)) {
29500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29501 }
29502 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29503 result = (wxColour *)& ((arg1)->colBg);
29504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29505 return resultobj;
29506 fail:
29507 return NULL;
29508 }
29509
29510
29511 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 PyObject *obj;
29513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29514 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29515 return SWIG_Py_Void();
29516 }
29517
29518 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29519 return SWIG_Python_InitShadowInstance(args);
29520 }
29521
29522 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29523 PyObject *resultobj = 0;
29524 wxWindow *arg1 = (wxWindow *) 0 ;
29525 int arg2 = (int) (int)-1 ;
29526 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29527 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29528 wxSize const &arg4_defvalue = wxDefaultSize ;
29529 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29530 long arg5 = (long) 0 ;
29531 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29532 wxString *arg6 = (wxString *) &arg6_defvalue ;
29533 wxWindow *result = 0 ;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 int val2 ;
29537 int ecode2 = 0 ;
29538 wxPoint temp3 ;
29539 wxSize temp4 ;
29540 long val5 ;
29541 int ecode5 = 0 ;
29542 bool temp6 = false ;
29543 PyObject * obj0 = 0 ;
29544 PyObject * obj1 = 0 ;
29545 PyObject * obj2 = 0 ;
29546 PyObject * obj3 = 0 ;
29547 PyObject * obj4 = 0 ;
29548 PyObject * obj5 = 0 ;
29549 char * kwnames[] = {
29550 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29551 };
29552
29553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29555 if (!SWIG_IsOK(res1)) {
29556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29557 }
29558 arg1 = reinterpret_cast< wxWindow * >(argp1);
29559 if (obj1) {
29560 ecode2 = SWIG_AsVal_int(obj1, &val2);
29561 if (!SWIG_IsOK(ecode2)) {
29562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29563 }
29564 arg2 = static_cast< int >(val2);
29565 }
29566 if (obj2) {
29567 {
29568 arg3 = &temp3;
29569 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29570 }
29571 }
29572 if (obj3) {
29573 {
29574 arg4 = &temp4;
29575 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29576 }
29577 }
29578 if (obj4) {
29579 ecode5 = SWIG_AsVal_long(obj4, &val5);
29580 if (!SWIG_IsOK(ecode5)) {
29581 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29582 }
29583 arg5 = static_cast< long >(val5);
29584 }
29585 if (obj5) {
29586 {
29587 arg6 = wxString_in_helper(obj5);
29588 if (arg6 == NULL) SWIG_fail;
29589 temp6 = true;
29590 }
29591 }
29592 {
29593 if (!wxPyCheckForApp()) SWIG_fail;
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29600 {
29601 if (temp6)
29602 delete arg6;
29603 }
29604 return resultobj;
29605 fail:
29606 {
29607 if (temp6)
29608 delete arg6;
29609 }
29610 return NULL;
29611 }
29612
29613
29614 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29615 PyObject *resultobj = 0;
29616 wxWindow *result = 0 ;
29617
29618 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29619 {
29620 if (!wxPyCheckForApp()) SWIG_fail;
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (wxWindow *)new wxWindow();
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj = 0;
29635 wxWindow *arg1 = (wxWindow *) 0 ;
29636 wxWindow *arg2 = (wxWindow *) 0 ;
29637 int arg3 = (int) (int)-1 ;
29638 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29639 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29640 wxSize const &arg5_defvalue = wxDefaultSize ;
29641 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29642 long arg6 = (long) 0 ;
29643 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29644 wxString *arg7 = (wxString *) &arg7_defvalue ;
29645 bool result;
29646 void *argp1 = 0 ;
29647 int res1 = 0 ;
29648 void *argp2 = 0 ;
29649 int res2 = 0 ;
29650 int val3 ;
29651 int ecode3 = 0 ;
29652 wxPoint temp4 ;
29653 wxSize temp5 ;
29654 long val6 ;
29655 int ecode6 = 0 ;
29656 bool temp7 = false ;
29657 PyObject * obj0 = 0 ;
29658 PyObject * obj1 = 0 ;
29659 PyObject * obj2 = 0 ;
29660 PyObject * obj3 = 0 ;
29661 PyObject * obj4 = 0 ;
29662 PyObject * obj5 = 0 ;
29663 PyObject * obj6 = 0 ;
29664 char * kwnames[] = {
29665 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29666 };
29667
29668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29670 if (!SWIG_IsOK(res1)) {
29671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29672 }
29673 arg1 = reinterpret_cast< wxWindow * >(argp1);
29674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29675 if (!SWIG_IsOK(res2)) {
29676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29677 }
29678 arg2 = reinterpret_cast< wxWindow * >(argp2);
29679 if (obj2) {
29680 ecode3 = SWIG_AsVal_int(obj2, &val3);
29681 if (!SWIG_IsOK(ecode3)) {
29682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29683 }
29684 arg3 = static_cast< int >(val3);
29685 }
29686 if (obj3) {
29687 {
29688 arg4 = &temp4;
29689 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29690 }
29691 }
29692 if (obj4) {
29693 {
29694 arg5 = &temp5;
29695 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29696 }
29697 }
29698 if (obj5) {
29699 ecode6 = SWIG_AsVal_long(obj5, &val6);
29700 if (!SWIG_IsOK(ecode6)) {
29701 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29702 }
29703 arg6 = static_cast< long >(val6);
29704 }
29705 if (obj6) {
29706 {
29707 arg7 = wxString_in_helper(obj6);
29708 if (arg7 == NULL) SWIG_fail;
29709 temp7 = true;
29710 }
29711 }
29712 {
29713 PyThreadState* __tstate = wxPyBeginAllowThreads();
29714 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29715 wxPyEndAllowThreads(__tstate);
29716 if (PyErr_Occurred()) SWIG_fail;
29717 }
29718 {
29719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29720 }
29721 {
29722 if (temp7)
29723 delete arg7;
29724 }
29725 return resultobj;
29726 fail:
29727 {
29728 if (temp7)
29729 delete arg7;
29730 }
29731 return NULL;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29736 PyObject *resultobj = 0;
29737 wxWindow *arg1 = (wxWindow *) 0 ;
29738 bool arg2 = (bool) false ;
29739 bool result;
29740 void *argp1 = 0 ;
29741 int res1 = 0 ;
29742 bool val2 ;
29743 int ecode2 = 0 ;
29744 PyObject * obj0 = 0 ;
29745 PyObject * obj1 = 0 ;
29746 char * kwnames[] = {
29747 (char *) "self",(char *) "force", NULL
29748 };
29749
29750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29752 if (!SWIG_IsOK(res1)) {
29753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29754 }
29755 arg1 = reinterpret_cast< wxWindow * >(argp1);
29756 if (obj1) {
29757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29758 if (!SWIG_IsOK(ecode2)) {
29759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29760 }
29761 arg2 = static_cast< bool >(val2);
29762 }
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (bool)(arg1)->Close(arg2);
29766 wxPyEndAllowThreads(__tstate);
29767 if (PyErr_Occurred()) SWIG_fail;
29768 }
29769 {
29770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29771 }
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29779 PyObject *resultobj = 0;
29780 wxWindow *arg1 = (wxWindow *) 0 ;
29781 bool result;
29782 void *argp1 = 0 ;
29783 int res1 = 0 ;
29784 PyObject *swig_obj[1] ;
29785
29786 if (!args) SWIG_fail;
29787 swig_obj[0] = args;
29788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29791 }
29792 arg1 = reinterpret_cast< wxWindow * >(argp1);
29793 {
29794 PyThreadState* __tstate = wxPyBeginAllowThreads();
29795 result = (bool)(arg1)->Destroy();
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 {
29800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29801 }
29802 return resultobj;
29803 fail:
29804 return NULL;
29805 }
29806
29807
29808 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29809 PyObject *resultobj = 0;
29810 wxWindow *arg1 = (wxWindow *) 0 ;
29811 bool result;
29812 void *argp1 = 0 ;
29813 int res1 = 0 ;
29814 PyObject *swig_obj[1] ;
29815
29816 if (!args) SWIG_fail;
29817 swig_obj[0] = args;
29818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29819 if (!SWIG_IsOK(res1)) {
29820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29821 }
29822 arg1 = reinterpret_cast< wxWindow * >(argp1);
29823 {
29824 PyThreadState* __tstate = wxPyBeginAllowThreads();
29825 result = (bool)(arg1)->DestroyChildren();
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 {
29830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29839 PyObject *resultobj = 0;
29840 wxWindow *arg1 = (wxWindow *) 0 ;
29841 bool result;
29842 void *argp1 = 0 ;
29843 int res1 = 0 ;
29844 PyObject *swig_obj[1] ;
29845
29846 if (!args) SWIG_fail;
29847 swig_obj[0] = args;
29848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29849 if (!SWIG_IsOK(res1)) {
29850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29851 }
29852 arg1 = reinterpret_cast< wxWindow * >(argp1);
29853 {
29854 PyThreadState* __tstate = wxPyBeginAllowThreads();
29855 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 {
29860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29861 }
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29869 PyObject *resultobj = 0;
29870 wxWindow *arg1 = (wxWindow *) 0 ;
29871 wxString *arg2 = 0 ;
29872 void *argp1 = 0 ;
29873 int res1 = 0 ;
29874 bool temp2 = false ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "label", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29885 }
29886 arg1 = reinterpret_cast< wxWindow * >(argp1);
29887 {
29888 arg2 = wxString_in_helper(obj1);
29889 if (arg2 == NULL) SWIG_fail;
29890 temp2 = true;
29891 }
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->SetLabel((wxString const &)*arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 {
29900 if (temp2)
29901 delete arg2;
29902 }
29903 return resultobj;
29904 fail:
29905 {
29906 if (temp2)
29907 delete arg2;
29908 }
29909 return NULL;
29910 }
29911
29912
29913 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29914 PyObject *resultobj = 0;
29915 wxWindow *arg1 = (wxWindow *) 0 ;
29916 wxString result;
29917 void *argp1 = 0 ;
29918 int res1 = 0 ;
29919 PyObject *swig_obj[1] ;
29920
29921 if (!args) SWIG_fail;
29922 swig_obj[0] = args;
29923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29924 if (!SWIG_IsOK(res1)) {
29925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29926 }
29927 arg1 = reinterpret_cast< wxWindow * >(argp1);
29928 {
29929 PyThreadState* __tstate = wxPyBeginAllowThreads();
29930 result = ((wxWindow const *)arg1)->GetLabel();
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 #if wxUSE_UNICODE
29936 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29937 #else
29938 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29939 #endif
29940 }
29941 return resultobj;
29942 fail:
29943 return NULL;
29944 }
29945
29946
29947 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29948 PyObject *resultobj = 0;
29949 wxWindow *arg1 = (wxWindow *) 0 ;
29950 wxString *arg2 = 0 ;
29951 void *argp1 = 0 ;
29952 int res1 = 0 ;
29953 bool temp2 = false ;
29954 PyObject * obj0 = 0 ;
29955 PyObject * obj1 = 0 ;
29956 char * kwnames[] = {
29957 (char *) "self",(char *) "name", NULL
29958 };
29959
29960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29964 }
29965 arg1 = reinterpret_cast< wxWindow * >(argp1);
29966 {
29967 arg2 = wxString_in_helper(obj1);
29968 if (arg2 == NULL) SWIG_fail;
29969 temp2 = true;
29970 }
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 (arg1)->SetName((wxString const &)*arg2);
29974 wxPyEndAllowThreads(__tstate);
29975 if (PyErr_Occurred()) SWIG_fail;
29976 }
29977 resultobj = SWIG_Py_Void();
29978 {
29979 if (temp2)
29980 delete arg2;
29981 }
29982 return resultobj;
29983 fail:
29984 {
29985 if (temp2)
29986 delete arg2;
29987 }
29988 return NULL;
29989 }
29990
29991
29992 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29993 PyObject *resultobj = 0;
29994 wxWindow *arg1 = (wxWindow *) 0 ;
29995 wxString result;
29996 void *argp1 = 0 ;
29997 int res1 = 0 ;
29998 PyObject *swig_obj[1] ;
29999
30000 if (!args) SWIG_fail;
30001 swig_obj[0] = args;
30002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30005 }
30006 arg1 = reinterpret_cast< wxWindow * >(argp1);
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = ((wxWindow const *)arg1)->GetName();
30010 wxPyEndAllowThreads(__tstate);
30011 if (PyErr_Occurred()) SWIG_fail;
30012 }
30013 {
30014 #if wxUSE_UNICODE
30015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30016 #else
30017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30018 #endif
30019 }
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30027 PyObject *resultobj = 0;
30028 wxWindow *arg1 = (wxWindow *) 0 ;
30029 wxWindowVariant arg2 ;
30030 void *argp1 = 0 ;
30031 int res1 = 0 ;
30032 int val2 ;
30033 int ecode2 = 0 ;
30034 PyObject * obj0 = 0 ;
30035 PyObject * obj1 = 0 ;
30036 char * kwnames[] = {
30037 (char *) "self",(char *) "variant", NULL
30038 };
30039
30040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30044 }
30045 arg1 = reinterpret_cast< wxWindow * >(argp1);
30046 ecode2 = SWIG_AsVal_int(obj1, &val2);
30047 if (!SWIG_IsOK(ecode2)) {
30048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30049 }
30050 arg2 = static_cast< wxWindowVariant >(val2);
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 (arg1)->SetWindowVariant(arg2);
30054 wxPyEndAllowThreads(__tstate);
30055 if (PyErr_Occurred()) SWIG_fail;
30056 }
30057 resultobj = SWIG_Py_Void();
30058 return resultobj;
30059 fail:
30060 return NULL;
30061 }
30062
30063
30064 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30065 PyObject *resultobj = 0;
30066 wxWindow *arg1 = (wxWindow *) 0 ;
30067 wxWindowVariant result;
30068 void *argp1 = 0 ;
30069 int res1 = 0 ;
30070 PyObject *swig_obj[1] ;
30071
30072 if (!args) SWIG_fail;
30073 swig_obj[0] = args;
30074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30075 if (!SWIG_IsOK(res1)) {
30076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30077 }
30078 arg1 = reinterpret_cast< wxWindow * >(argp1);
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_From_int(static_cast< int >(result));
30086 return resultobj;
30087 fail:
30088 return NULL;
30089 }
30090
30091
30092 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30093 PyObject *resultobj = 0;
30094 wxWindow *arg1 = (wxWindow *) 0 ;
30095 int arg2 ;
30096 void *argp1 = 0 ;
30097 int res1 = 0 ;
30098 int val2 ;
30099 int ecode2 = 0 ;
30100 PyObject * obj0 = 0 ;
30101 PyObject * obj1 = 0 ;
30102 char * kwnames[] = {
30103 (char *) "self",(char *) "winid", NULL
30104 };
30105
30106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30108 if (!SWIG_IsOK(res1)) {
30109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30110 }
30111 arg1 = reinterpret_cast< wxWindow * >(argp1);
30112 ecode2 = SWIG_AsVal_int(obj1, &val2);
30113 if (!SWIG_IsOK(ecode2)) {
30114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30115 }
30116 arg2 = static_cast< int >(val2);
30117 {
30118 PyThreadState* __tstate = wxPyBeginAllowThreads();
30119 (arg1)->SetId(arg2);
30120 wxPyEndAllowThreads(__tstate);
30121 if (PyErr_Occurred()) SWIG_fail;
30122 }
30123 resultobj = SWIG_Py_Void();
30124 return resultobj;
30125 fail:
30126 return NULL;
30127 }
30128
30129
30130 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131 PyObject *resultobj = 0;
30132 wxWindow *arg1 = (wxWindow *) 0 ;
30133 int result;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 PyObject *swig_obj[1] ;
30137
30138 if (!args) SWIG_fail;
30139 swig_obj[0] = args;
30140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30141 if (!SWIG_IsOK(res1)) {
30142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30143 }
30144 arg1 = reinterpret_cast< wxWindow * >(argp1);
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 result = (int)((wxWindow const *)arg1)->GetId();
30148 wxPyEndAllowThreads(__tstate);
30149 if (PyErr_Occurred()) SWIG_fail;
30150 }
30151 resultobj = SWIG_From_int(static_cast< int >(result));
30152 return resultobj;
30153 fail:
30154 return NULL;
30155 }
30156
30157
30158 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30159 PyObject *resultobj = 0;
30160 int result;
30161
30162 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 result = (int)wxWindow::NewControlId();
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_From_int(static_cast< int >(result));
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 int arg1 ;
30179 int result;
30180 int val1 ;
30181 int ecode1 = 0 ;
30182 PyObject * obj0 = 0 ;
30183 char * kwnames[] = {
30184 (char *) "winid", NULL
30185 };
30186
30187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30188 ecode1 = SWIG_AsVal_int(obj0, &val1);
30189 if (!SWIG_IsOK(ecode1)) {
30190 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30191 }
30192 arg1 = static_cast< int >(val1);
30193 {
30194 PyThreadState* __tstate = wxPyBeginAllowThreads();
30195 result = (int)wxWindow::NextControlId(arg1);
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 resultobj = SWIG_From_int(static_cast< int >(result));
30200 return resultobj;
30201 fail:
30202 return NULL;
30203 }
30204
30205
30206 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30207 PyObject *resultobj = 0;
30208 int arg1 ;
30209 int result;
30210 int val1 ;
30211 int ecode1 = 0 ;
30212 PyObject * obj0 = 0 ;
30213 char * kwnames[] = {
30214 (char *) "winid", NULL
30215 };
30216
30217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30218 ecode1 = SWIG_AsVal_int(obj0, &val1);
30219 if (!SWIG_IsOK(ecode1)) {
30220 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30221 }
30222 arg1 = static_cast< int >(val1);
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 result = (int)wxWindow::PrevControlId(arg1);
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 resultobj = SWIG_From_int(static_cast< int >(result));
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = 0;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 wxSize *arg2 = 0 ;
30240 void *argp1 = 0 ;
30241 int res1 = 0 ;
30242 wxSize temp2 ;
30243 PyObject * obj0 = 0 ;
30244 PyObject * obj1 = 0 ;
30245 char * kwnames[] = {
30246 (char *) "self",(char *) "size", NULL
30247 };
30248
30249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30253 }
30254 arg1 = reinterpret_cast< wxWindow * >(argp1);
30255 {
30256 arg2 = &temp2;
30257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 (arg1)->SetSize((wxSize const &)*arg2);
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_Py_Void();
30266 return resultobj;
30267 fail:
30268 return NULL;
30269 }
30270
30271
30272 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30273 PyObject *resultobj = 0;
30274 wxWindow *arg1 = (wxWindow *) 0 ;
30275 int arg2 ;
30276 int arg3 ;
30277 int arg4 ;
30278 int arg5 ;
30279 int arg6 = (int) wxSIZE_AUTO ;
30280 void *argp1 = 0 ;
30281 int res1 = 0 ;
30282 int val2 ;
30283 int ecode2 = 0 ;
30284 int val3 ;
30285 int ecode3 = 0 ;
30286 int val4 ;
30287 int ecode4 = 0 ;
30288 int val5 ;
30289 int ecode5 = 0 ;
30290 int val6 ;
30291 int ecode6 = 0 ;
30292 PyObject * obj0 = 0 ;
30293 PyObject * obj1 = 0 ;
30294 PyObject * obj2 = 0 ;
30295 PyObject * obj3 = 0 ;
30296 PyObject * obj4 = 0 ;
30297 PyObject * obj5 = 0 ;
30298 char * kwnames[] = {
30299 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30300 };
30301
30302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30304 if (!SWIG_IsOK(res1)) {
30305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30306 }
30307 arg1 = reinterpret_cast< wxWindow * >(argp1);
30308 ecode2 = SWIG_AsVal_int(obj1, &val2);
30309 if (!SWIG_IsOK(ecode2)) {
30310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30311 }
30312 arg2 = static_cast< int >(val2);
30313 ecode3 = SWIG_AsVal_int(obj2, &val3);
30314 if (!SWIG_IsOK(ecode3)) {
30315 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30316 }
30317 arg3 = static_cast< int >(val3);
30318 ecode4 = SWIG_AsVal_int(obj3, &val4);
30319 if (!SWIG_IsOK(ecode4)) {
30320 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30321 }
30322 arg4 = static_cast< int >(val4);
30323 ecode5 = SWIG_AsVal_int(obj4, &val5);
30324 if (!SWIG_IsOK(ecode5)) {
30325 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30326 }
30327 arg5 = static_cast< int >(val5);
30328 if (obj5) {
30329 ecode6 = SWIG_AsVal_int(obj5, &val6);
30330 if (!SWIG_IsOK(ecode6)) {
30331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30332 }
30333 arg6 = static_cast< int >(val6);
30334 }
30335 {
30336 PyThreadState* __tstate = wxPyBeginAllowThreads();
30337 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30338 wxPyEndAllowThreads(__tstate);
30339 if (PyErr_Occurred()) SWIG_fail;
30340 }
30341 resultobj = SWIG_Py_Void();
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = 0;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 wxRect *arg2 = 0 ;
30352 int arg3 = (int) wxSIZE_AUTO ;
30353 void *argp1 = 0 ;
30354 int res1 = 0 ;
30355 wxRect temp2 ;
30356 int val3 ;
30357 int ecode3 = 0 ;
30358 PyObject * obj0 = 0 ;
30359 PyObject * obj1 = 0 ;
30360 PyObject * obj2 = 0 ;
30361 char * kwnames[] = {
30362 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30363 };
30364
30365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30367 if (!SWIG_IsOK(res1)) {
30368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30369 }
30370 arg1 = reinterpret_cast< wxWindow * >(argp1);
30371 {
30372 arg2 = &temp2;
30373 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30374 }
30375 if (obj2) {
30376 ecode3 = SWIG_AsVal_int(obj2, &val3);
30377 if (!SWIG_IsOK(ecode3)) {
30378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30379 }
30380 arg3 = static_cast< int >(val3);
30381 }
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_Py_Void();
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj = 0;
30397 wxWindow *arg1 = (wxWindow *) 0 ;
30398 int arg2 ;
30399 int arg3 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 int val2 ;
30403 int ecode2 = 0 ;
30404 int val3 ;
30405 int ecode3 = 0 ;
30406 PyObject * obj0 = 0 ;
30407 PyObject * obj1 = 0 ;
30408 PyObject * obj2 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "self",(char *) "width",(char *) "height", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 ecode2 = SWIG_AsVal_int(obj1, &val2);
30420 if (!SWIG_IsOK(ecode2)) {
30421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30422 }
30423 arg2 = static_cast< int >(val2);
30424 ecode3 = SWIG_AsVal_int(obj2, &val3);
30425 if (!SWIG_IsOK(ecode3)) {
30426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30427 }
30428 arg3 = static_cast< int >(val3);
30429 {
30430 PyThreadState* __tstate = wxPyBeginAllowThreads();
30431 (arg1)->SetSize(arg2,arg3);
30432 wxPyEndAllowThreads(__tstate);
30433 if (PyErr_Occurred()) SWIG_fail;
30434 }
30435 resultobj = SWIG_Py_Void();
30436 return resultobj;
30437 fail:
30438 return NULL;
30439 }
30440
30441
30442 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30443 PyObject *resultobj = 0;
30444 wxWindow *arg1 = (wxWindow *) 0 ;
30445 wxPoint *arg2 = 0 ;
30446 int arg3 = (int) wxSIZE_USE_EXISTING ;
30447 void *argp1 = 0 ;
30448 int res1 = 0 ;
30449 wxPoint temp2 ;
30450 int val3 ;
30451 int ecode3 = 0 ;
30452 PyObject * obj0 = 0 ;
30453 PyObject * obj1 = 0 ;
30454 PyObject * obj2 = 0 ;
30455 char * kwnames[] = {
30456 (char *) "self",(char *) "pt",(char *) "flags", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30463 }
30464 arg1 = reinterpret_cast< wxWindow * >(argp1);
30465 {
30466 arg2 = &temp2;
30467 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30468 }
30469 if (obj2) {
30470 ecode3 = SWIG_AsVal_int(obj2, &val3);
30471 if (!SWIG_IsOK(ecode3)) {
30472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30473 }
30474 arg3 = static_cast< int >(val3);
30475 }
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 (arg1)->Move((wxPoint const &)*arg2,arg3);
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 resultobj = SWIG_Py_Void();
30483 return resultobj;
30484 fail:
30485 return NULL;
30486 }
30487
30488
30489 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30490 PyObject *resultobj = 0;
30491 wxWindow *arg1 = (wxWindow *) 0 ;
30492 int arg2 ;
30493 int arg3 ;
30494 int arg4 = (int) wxSIZE_USE_EXISTING ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 int val2 ;
30498 int ecode2 = 0 ;
30499 int val3 ;
30500 int ecode3 = 0 ;
30501 int val4 ;
30502 int ecode4 = 0 ;
30503 PyObject * obj0 = 0 ;
30504 PyObject * obj1 = 0 ;
30505 PyObject * obj2 = 0 ;
30506 PyObject * obj3 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30515 }
30516 arg1 = reinterpret_cast< wxWindow * >(argp1);
30517 ecode2 = SWIG_AsVal_int(obj1, &val2);
30518 if (!SWIG_IsOK(ecode2)) {
30519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30520 }
30521 arg2 = static_cast< int >(val2);
30522 ecode3 = SWIG_AsVal_int(obj2, &val3);
30523 if (!SWIG_IsOK(ecode3)) {
30524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30525 }
30526 arg3 = static_cast< int >(val3);
30527 if (obj3) {
30528 ecode4 = SWIG_AsVal_int(obj3, &val4);
30529 if (!SWIG_IsOK(ecode4)) {
30530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30531 }
30532 arg4 = static_cast< int >(val4);
30533 }
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 (arg1)->Move(arg2,arg3,arg4);
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_Py_Void();
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj = 0;
30549 wxWindow *arg1 = (wxWindow *) 0 ;
30550 wxSize const &arg2_defvalue = wxDefaultSize ;
30551 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 wxSize temp2 ;
30555 PyObject * obj0 = 0 ;
30556 PyObject * obj1 = 0 ;
30557 char * kwnames[] = {
30558 (char *) "self",(char *) "size", NULL
30559 };
30560
30561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30563 if (!SWIG_IsOK(res1)) {
30564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30565 }
30566 arg1 = reinterpret_cast< wxWindow * >(argp1);
30567 if (obj1) {
30568 {
30569 arg2 = &temp2;
30570 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30571 }
30572 }
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30576 wxPyEndAllowThreads(__tstate);
30577 if (PyErr_Occurred()) SWIG_fail;
30578 }
30579 resultobj = SWIG_Py_Void();
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxWindow *arg1 = (wxWindow *) 0 ;
30589 void *argp1 = 0 ;
30590 int res1 = 0 ;
30591 PyObject *swig_obj[1] ;
30592
30593 if (!args) SWIG_fail;
30594 swig_obj[0] = args;
30595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30596 if (!SWIG_IsOK(res1)) {
30597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30598 }
30599 arg1 = reinterpret_cast< wxWindow * >(argp1);
30600 {
30601 PyThreadState* __tstate = wxPyBeginAllowThreads();
30602 (arg1)->Raise();
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_Py_Void();
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30614 PyObject *resultobj = 0;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 PyObject *swig_obj[1] ;
30619
30620 if (!args) SWIG_fail;
30621 swig_obj[0] = args;
30622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30623 if (!SWIG_IsOK(res1)) {
30624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30625 }
30626 arg1 = reinterpret_cast< wxWindow * >(argp1);
30627 {
30628 PyThreadState* __tstate = wxPyBeginAllowThreads();
30629 (arg1)->Lower();
30630 wxPyEndAllowThreads(__tstate);
30631 if (PyErr_Occurred()) SWIG_fail;
30632 }
30633 resultobj = SWIG_Py_Void();
30634 return resultobj;
30635 fail:
30636 return NULL;
30637 }
30638
30639
30640 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30641 PyObject *resultobj = 0;
30642 wxWindow *arg1 = (wxWindow *) 0 ;
30643 wxSize *arg2 = 0 ;
30644 void *argp1 = 0 ;
30645 int res1 = 0 ;
30646 wxSize temp2 ;
30647 PyObject * obj0 = 0 ;
30648 PyObject * obj1 = 0 ;
30649 char * kwnames[] = {
30650 (char *) "self",(char *) "size", NULL
30651 };
30652
30653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30655 if (!SWIG_IsOK(res1)) {
30656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30657 }
30658 arg1 = reinterpret_cast< wxWindow * >(argp1);
30659 {
30660 arg2 = &temp2;
30661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30662 }
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 (arg1)->SetClientSize((wxSize const &)*arg2);
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_Py_Void();
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxWindow *arg1 = (wxWindow *) 0 ;
30679 int arg2 ;
30680 int arg3 ;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 int val2 ;
30684 int ecode2 = 0 ;
30685 int val3 ;
30686 int ecode3 = 0 ;
30687 PyObject * obj0 = 0 ;
30688 PyObject * obj1 = 0 ;
30689 PyObject * obj2 = 0 ;
30690 char * kwnames[] = {
30691 (char *) "self",(char *) "width",(char *) "height", NULL
30692 };
30693
30694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30696 if (!SWIG_IsOK(res1)) {
30697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30698 }
30699 arg1 = reinterpret_cast< wxWindow * >(argp1);
30700 ecode2 = SWIG_AsVal_int(obj1, &val2);
30701 if (!SWIG_IsOK(ecode2)) {
30702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30703 }
30704 arg2 = static_cast< int >(val2);
30705 ecode3 = SWIG_AsVal_int(obj2, &val3);
30706 if (!SWIG_IsOK(ecode3)) {
30707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30708 }
30709 arg3 = static_cast< int >(val3);
30710 {
30711 PyThreadState* __tstate = wxPyBeginAllowThreads();
30712 (arg1)->SetClientSize(arg2,arg3);
30713 wxPyEndAllowThreads(__tstate);
30714 if (PyErr_Occurred()) SWIG_fail;
30715 }
30716 resultobj = SWIG_Py_Void();
30717 return resultobj;
30718 fail:
30719 return NULL;
30720 }
30721
30722
30723 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30724 PyObject *resultobj = 0;
30725 wxWindow *arg1 = (wxWindow *) 0 ;
30726 wxRect *arg2 = 0 ;
30727 void *argp1 = 0 ;
30728 int res1 = 0 ;
30729 wxRect temp2 ;
30730 PyObject * obj0 = 0 ;
30731 PyObject * obj1 = 0 ;
30732 char * kwnames[] = {
30733 (char *) "self",(char *) "rect", NULL
30734 };
30735
30736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30738 if (!SWIG_IsOK(res1)) {
30739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30740 }
30741 arg1 = reinterpret_cast< wxWindow * >(argp1);
30742 {
30743 arg2 = &temp2;
30744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30745 }
30746 {
30747 PyThreadState* __tstate = wxPyBeginAllowThreads();
30748 (arg1)->SetClientSize((wxRect const &)*arg2);
30749 wxPyEndAllowThreads(__tstate);
30750 if (PyErr_Occurred()) SWIG_fail;
30751 }
30752 resultobj = SWIG_Py_Void();
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30760 PyObject *resultobj = 0;
30761 wxWindow *arg1 = (wxWindow *) 0 ;
30762 wxPoint result;
30763 void *argp1 = 0 ;
30764 int res1 = 0 ;
30765 PyObject *swig_obj[1] ;
30766
30767 if (!args) SWIG_fail;
30768 swig_obj[0] = args;
30769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30770 if (!SWIG_IsOK(res1)) {
30771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30772 }
30773 arg1 = reinterpret_cast< wxWindow * >(argp1);
30774 {
30775 PyThreadState* __tstate = wxPyBeginAllowThreads();
30776 result = ((wxWindow const *)arg1)->GetPosition();
30777 wxPyEndAllowThreads(__tstate);
30778 if (PyErr_Occurred()) SWIG_fail;
30779 }
30780 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30788 PyObject *resultobj = 0;
30789 wxWindow *arg1 = (wxWindow *) 0 ;
30790 int *arg2 = (int *) 0 ;
30791 int *arg3 = (int *) 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 int temp2 ;
30795 int res2 = SWIG_TMPOBJ ;
30796 int temp3 ;
30797 int res3 = SWIG_TMPOBJ ;
30798 PyObject *swig_obj[1] ;
30799
30800 arg2 = &temp2;
30801 arg3 = &temp3;
30802 if (!args) SWIG_fail;
30803 swig_obj[0] = args;
30804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30805 if (!SWIG_IsOK(res1)) {
30806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30807 }
30808 arg1 = reinterpret_cast< wxWindow * >(argp1);
30809 {
30810 PyThreadState* __tstate = wxPyBeginAllowThreads();
30811 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30812 wxPyEndAllowThreads(__tstate);
30813 if (PyErr_Occurred()) SWIG_fail;
30814 }
30815 resultobj = SWIG_Py_Void();
30816 if (SWIG_IsTmpObj(res2)) {
30817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30818 } else {
30819 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30821 }
30822 if (SWIG_IsTmpObj(res3)) {
30823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30824 } else {
30825 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 wxPoint result;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30847 }
30848 arg1 = reinterpret_cast< wxWindow * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = ((wxWindow const *)arg1)->GetScreenPosition();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30856 return resultobj;
30857 fail:
30858 return NULL;
30859 }
30860
30861
30862 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30863 PyObject *resultobj = 0;
30864 wxWindow *arg1 = (wxWindow *) 0 ;
30865 int *arg2 = (int *) 0 ;
30866 int *arg3 = (int *) 0 ;
30867 void *argp1 = 0 ;
30868 int res1 = 0 ;
30869 int temp2 ;
30870 int res2 = SWIG_TMPOBJ ;
30871 int temp3 ;
30872 int res3 = SWIG_TMPOBJ ;
30873 PyObject *swig_obj[1] ;
30874
30875 arg2 = &temp2;
30876 arg3 = &temp3;
30877 if (!args) SWIG_fail;
30878 swig_obj[0] = args;
30879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30882 }
30883 arg1 = reinterpret_cast< wxWindow * >(argp1);
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30887 wxPyEndAllowThreads(__tstate);
30888 if (PyErr_Occurred()) SWIG_fail;
30889 }
30890 resultobj = SWIG_Py_Void();
30891 if (SWIG_IsTmpObj(res2)) {
30892 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30893 } else {
30894 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30895 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30896 }
30897 if (SWIG_IsTmpObj(res3)) {
30898 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30899 } else {
30900 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 wxRect result;
30913 void *argp1 = 0 ;
30914 int res1 = 0 ;
30915 PyObject *swig_obj[1] ;
30916
30917 if (!args) SWIG_fail;
30918 swig_obj[0] = args;
30919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30920 if (!SWIG_IsOK(res1)) {
30921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30922 }
30923 arg1 = reinterpret_cast< wxWindow * >(argp1);
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = ((wxWindow const *)arg1)->GetScreenRect();
30927 wxPyEndAllowThreads(__tstate);
30928 if (PyErr_Occurred()) SWIG_fail;
30929 }
30930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30938 PyObject *resultobj = 0;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 wxSize result;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 PyObject *swig_obj[1] ;
30944
30945 if (!args) SWIG_fail;
30946 swig_obj[0] = args;
30947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30948 if (!SWIG_IsOK(res1)) {
30949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30950 }
30951 arg1 = reinterpret_cast< wxWindow * >(argp1);
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 result = ((wxWindow const *)arg1)->GetSize();
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 int *arg2 = (int *) 0 ;
30969 int *arg3 = (int *) 0 ;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 int temp2 ;
30973 int res2 = SWIG_TMPOBJ ;
30974 int temp3 ;
30975 int res3 = SWIG_TMPOBJ ;
30976 PyObject *swig_obj[1] ;
30977
30978 arg2 = &temp2;
30979 arg3 = &temp3;
30980 if (!args) SWIG_fail;
30981 swig_obj[0] = args;
30982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 resultobj = SWIG_Py_Void();
30994 if (SWIG_IsTmpObj(res2)) {
30995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30996 } else {
30997 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30999 }
31000 if (SWIG_IsTmpObj(res3)) {
31001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31002 } else {
31003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31005 }
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxRect result;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 PyObject *swig_obj[1] ;
31019
31020 if (!args) SWIG_fail;
31021 swig_obj[0] = args;
31022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxWindow const *)arg1)->GetRect();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 wxSize result;
31044 void *argp1 = 0 ;
31045 int res1 = 0 ;
31046 PyObject *swig_obj[1] ;
31047
31048 if (!args) SWIG_fail;
31049 swig_obj[0] = args;
31050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31051 if (!SWIG_IsOK(res1)) {
31052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31053 }
31054 arg1 = reinterpret_cast< wxWindow * >(argp1);
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = ((wxWindow const *)arg1)->GetClientSize();
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31062 return resultobj;
31063 fail:
31064 return NULL;
31065 }
31066
31067
31068 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31069 PyObject *resultobj = 0;
31070 wxWindow *arg1 = (wxWindow *) 0 ;
31071 int *arg2 = (int *) 0 ;
31072 int *arg3 = (int *) 0 ;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 int temp2 ;
31076 int res2 = SWIG_TMPOBJ ;
31077 int temp3 ;
31078 int res3 = SWIG_TMPOBJ ;
31079 PyObject *swig_obj[1] ;
31080
31081 arg2 = &temp2;
31082 arg3 = &temp3;
31083 if (!args) SWIG_fail;
31084 swig_obj[0] = args;
31085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31086 if (!SWIG_IsOK(res1)) {
31087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31088 }
31089 arg1 = reinterpret_cast< wxWindow * >(argp1);
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 resultobj = SWIG_Py_Void();
31097 if (SWIG_IsTmpObj(res2)) {
31098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31099 } else {
31100 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31102 }
31103 if (SWIG_IsTmpObj(res3)) {
31104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31105 } else {
31106 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31108 }
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31116 PyObject *resultobj = 0;
31117 wxWindow *arg1 = (wxWindow *) 0 ;
31118 wxPoint result;
31119 void *argp1 = 0 ;
31120 int res1 = 0 ;
31121 PyObject *swig_obj[1] ;
31122
31123 if (!args) SWIG_fail;
31124 swig_obj[0] = args;
31125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31126 if (!SWIG_IsOK(res1)) {
31127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31128 }
31129 arg1 = reinterpret_cast< wxWindow * >(argp1);
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31144 PyObject *resultobj = 0;
31145 wxWindow *arg1 = (wxWindow *) 0 ;
31146 wxRect result;
31147 void *argp1 = 0 ;
31148 int res1 = 0 ;
31149 PyObject *swig_obj[1] ;
31150
31151 if (!args) SWIG_fail;
31152 swig_obj[0] = args;
31153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31154 if (!SWIG_IsOK(res1)) {
31155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31156 }
31157 arg1 = reinterpret_cast< wxWindow * >(argp1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 result = ((wxWindow const *)arg1)->GetClientRect();
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31172 PyObject *resultobj = 0;
31173 wxWindow *arg1 = (wxWindow *) 0 ;
31174 wxSize result;
31175 void *argp1 = 0 ;
31176 int res1 = 0 ;
31177 PyObject *swig_obj[1] ;
31178
31179 if (!args) SWIG_fail;
31180 swig_obj[0] = args;
31181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31182 if (!SWIG_IsOK(res1)) {
31183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31184 }
31185 arg1 = reinterpret_cast< wxWindow * >(argp1);
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = ((wxWindow const *)arg1)->GetBestSize();
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31200 PyObject *resultobj = 0;
31201 wxWindow *arg1 = (wxWindow *) 0 ;
31202 int *arg2 = (int *) 0 ;
31203 int *arg3 = (int *) 0 ;
31204 void *argp1 = 0 ;
31205 int res1 = 0 ;
31206 int temp2 ;
31207 int res2 = SWIG_TMPOBJ ;
31208 int temp3 ;
31209 int res3 = SWIG_TMPOBJ ;
31210 PyObject *swig_obj[1] ;
31211
31212 arg2 = &temp2;
31213 arg3 = &temp3;
31214 if (!args) SWIG_fail;
31215 swig_obj[0] = args;
31216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31219 }
31220 arg1 = reinterpret_cast< wxWindow * >(argp1);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_Py_Void();
31228 if (SWIG_IsTmpObj(res2)) {
31229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31230 } else {
31231 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31233 }
31234 if (SWIG_IsTmpObj(res3)) {
31235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31236 } else {
31237 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31239 }
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31247 PyObject *resultobj = 0;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 void *argp1 = 0 ;
31250 int res1 = 0 ;
31251 PyObject *swig_obj[1] ;
31252
31253 if (!args) SWIG_fail;
31254 swig_obj[0] = args;
31255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31256 if (!SWIG_IsOK(res1)) {
31257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31258 }
31259 arg1 = reinterpret_cast< wxWindow * >(argp1);
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 (arg1)->InvalidateBestSize();
31263 wxPyEndAllowThreads(__tstate);
31264 if (PyErr_Occurred()) SWIG_fail;
31265 }
31266 resultobj = SWIG_Py_Void();
31267 return resultobj;
31268 fail:
31269 return NULL;
31270 }
31271
31272
31273 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31274 PyObject *resultobj = 0;
31275 wxWindow *arg1 = (wxWindow *) 0 ;
31276 wxSize *arg2 = 0 ;
31277 void *argp1 = 0 ;
31278 int res1 = 0 ;
31279 wxSize temp2 ;
31280 PyObject * obj0 = 0 ;
31281 PyObject * obj1 = 0 ;
31282 char * kwnames[] = {
31283 (char *) "self",(char *) "size", NULL
31284 };
31285
31286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31290 }
31291 arg1 = reinterpret_cast< wxWindow * >(argp1);
31292 {
31293 arg2 = &temp2;
31294 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31295 }
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31299 wxPyEndAllowThreads(__tstate);
31300 if (PyErr_Occurred()) SWIG_fail;
31301 }
31302 resultobj = SWIG_Py_Void();
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *resultobj = 0;
31311 wxWindow *arg1 = (wxWindow *) 0 ;
31312 wxSize result;
31313 void *argp1 = 0 ;
31314 int res1 = 0 ;
31315 PyObject *swig_obj[1] ;
31316
31317 if (!args) SWIG_fail;
31318 swig_obj[0] = args;
31319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31322 }
31323 arg1 = reinterpret_cast< wxWindow * >(argp1);
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 PyObject *resultobj = 0;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 wxSize result;
31341 void *argp1 = 0 ;
31342 int res1 = 0 ;
31343 PyObject *swig_obj[1] ;
31344
31345 if (!args) SWIG_fail;
31346 swig_obj[0] = args;
31347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31348 if (!SWIG_IsOK(res1)) {
31349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31350 }
31351 arg1 = reinterpret_cast< wxWindow * >(argp1);
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31355 wxPyEndAllowThreads(__tstate);
31356 if (PyErr_Occurred()) SWIG_fail;
31357 }
31358 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31359 return resultobj;
31360 fail:
31361 return NULL;
31362 }
31363
31364
31365 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31366 PyObject *resultobj = 0;
31367 wxWindow *arg1 = (wxWindow *) 0 ;
31368 int arg2 = (int) wxBOTH ;
31369 void *argp1 = 0 ;
31370 int res1 = 0 ;
31371 int val2 ;
31372 int ecode2 = 0 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 char * kwnames[] = {
31376 (char *) "self",(char *) "direction", NULL
31377 };
31378
31379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31381 if (!SWIG_IsOK(res1)) {
31382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31383 }
31384 arg1 = reinterpret_cast< wxWindow * >(argp1);
31385 if (obj1) {
31386 ecode2 = SWIG_AsVal_int(obj1, &val2);
31387 if (!SWIG_IsOK(ecode2)) {
31388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31389 }
31390 arg2 = static_cast< int >(val2);
31391 }
31392 {
31393 PyThreadState* __tstate = wxPyBeginAllowThreads();
31394 (arg1)->Center(arg2);
31395 wxPyEndAllowThreads(__tstate);
31396 if (PyErr_Occurred()) SWIG_fail;
31397 }
31398 resultobj = SWIG_Py_Void();
31399 return resultobj;
31400 fail:
31401 return NULL;
31402 }
31403
31404
31405 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31406 PyObject *resultobj = 0;
31407 wxWindow *arg1 = (wxWindow *) 0 ;
31408 int arg2 = (int) wxBOTH ;
31409 void *argp1 = 0 ;
31410 int res1 = 0 ;
31411 int val2 ;
31412 int ecode2 = 0 ;
31413 PyObject * obj0 = 0 ;
31414 PyObject * obj1 = 0 ;
31415 char * kwnames[] = {
31416 (char *) "self",(char *) "dir", NULL
31417 };
31418
31419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31421 if (!SWIG_IsOK(res1)) {
31422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31423 }
31424 arg1 = reinterpret_cast< wxWindow * >(argp1);
31425 if (obj1) {
31426 ecode2 = SWIG_AsVal_int(obj1, &val2);
31427 if (!SWIG_IsOK(ecode2)) {
31428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31429 }
31430 arg2 = static_cast< int >(val2);
31431 }
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 (arg1)->CenterOnParent(arg2);
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_Py_Void();
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 wxWindow *arg1 = (wxWindow *) 0 ;
31448 void *argp1 = 0 ;
31449 int res1 = 0 ;
31450 PyObject *swig_obj[1] ;
31451
31452 if (!args) SWIG_fail;
31453 swig_obj[0] = args;
31454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31455 if (!SWIG_IsOK(res1)) {
31456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31457 }
31458 arg1 = reinterpret_cast< wxWindow * >(argp1);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 (arg1)->Fit();
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31473 PyObject *resultobj = 0;
31474 wxWindow *arg1 = (wxWindow *) 0 ;
31475 void *argp1 = 0 ;
31476 int res1 = 0 ;
31477 PyObject *swig_obj[1] ;
31478
31479 if (!args) SWIG_fail;
31480 swig_obj[0] = args;
31481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31482 if (!SWIG_IsOK(res1)) {
31483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31484 }
31485 arg1 = reinterpret_cast< wxWindow * >(argp1);
31486 {
31487 PyThreadState* __tstate = wxPyBeginAllowThreads();
31488 (arg1)->FitInside();
31489 wxPyEndAllowThreads(__tstate);
31490 if (PyErr_Occurred()) SWIG_fail;
31491 }
31492 resultobj = SWIG_Py_Void();
31493 return resultobj;
31494 fail:
31495 return NULL;
31496 }
31497
31498
31499 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31500 PyObject *resultobj = 0;
31501 wxWindow *arg1 = (wxWindow *) 0 ;
31502 int arg2 ;
31503 int arg3 ;
31504 int arg4 = (int) -1 ;
31505 int arg5 = (int) -1 ;
31506 int arg6 = (int) -1 ;
31507 int arg7 = (int) -1 ;
31508 void *argp1 = 0 ;
31509 int res1 = 0 ;
31510 int val2 ;
31511 int ecode2 = 0 ;
31512 int val3 ;
31513 int ecode3 = 0 ;
31514 int val4 ;
31515 int ecode4 = 0 ;
31516 int val5 ;
31517 int ecode5 = 0 ;
31518 int val6 ;
31519 int ecode6 = 0 ;
31520 int val7 ;
31521 int ecode7 = 0 ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 PyObject * obj2 = 0 ;
31525 PyObject * obj3 = 0 ;
31526 PyObject * obj4 = 0 ;
31527 PyObject * obj5 = 0 ;
31528 PyObject * obj6 = 0 ;
31529 char * kwnames[] = {
31530 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31531 };
31532
31533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31535 if (!SWIG_IsOK(res1)) {
31536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31537 }
31538 arg1 = reinterpret_cast< wxWindow * >(argp1);
31539 ecode2 = SWIG_AsVal_int(obj1, &val2);
31540 if (!SWIG_IsOK(ecode2)) {
31541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31542 }
31543 arg2 = static_cast< int >(val2);
31544 ecode3 = SWIG_AsVal_int(obj2, &val3);
31545 if (!SWIG_IsOK(ecode3)) {
31546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31547 }
31548 arg3 = static_cast< int >(val3);
31549 if (obj3) {
31550 ecode4 = SWIG_AsVal_int(obj3, &val4);
31551 if (!SWIG_IsOK(ecode4)) {
31552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31553 }
31554 arg4 = static_cast< int >(val4);
31555 }
31556 if (obj4) {
31557 ecode5 = SWIG_AsVal_int(obj4, &val5);
31558 if (!SWIG_IsOK(ecode5)) {
31559 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31560 }
31561 arg5 = static_cast< int >(val5);
31562 }
31563 if (obj5) {
31564 ecode6 = SWIG_AsVal_int(obj5, &val6);
31565 if (!SWIG_IsOK(ecode6)) {
31566 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31567 }
31568 arg6 = static_cast< int >(val6);
31569 }
31570 if (obj6) {
31571 ecode7 = SWIG_AsVal_int(obj6, &val7);
31572 if (!SWIG_IsOK(ecode7)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31574 }
31575 arg7 = static_cast< int >(val7);
31576 }
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_Py_Void();
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 wxSize *arg2 = 0 ;
31594 wxSize const &arg3_defvalue = wxDefaultSize ;
31595 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31596 wxSize const &arg4_defvalue = wxDefaultSize ;
31597 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31598 void *argp1 = 0 ;
31599 int res1 = 0 ;
31600 wxSize temp2 ;
31601 wxSize temp3 ;
31602 wxSize temp4 ;
31603 PyObject * obj0 = 0 ;
31604 PyObject * obj1 = 0 ;
31605 PyObject * obj2 = 0 ;
31606 PyObject * obj3 = 0 ;
31607 char * kwnames[] = {
31608 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31609 };
31610
31611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31615 }
31616 arg1 = reinterpret_cast< wxWindow * >(argp1);
31617 {
31618 arg2 = &temp2;
31619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31620 }
31621 if (obj2) {
31622 {
31623 arg3 = &temp3;
31624 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31625 }
31626 }
31627 if (obj3) {
31628 {
31629 arg4 = &temp4;
31630 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31631 }
31632 }
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_Py_Void();
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31647 PyObject *resultobj = 0;
31648 wxWindow *arg1 = (wxWindow *) 0 ;
31649 int arg2 ;
31650 int arg3 ;
31651 int arg4 = (int) -1 ;
31652 int arg5 = (int) -1 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 int val2 ;
31656 int ecode2 = 0 ;
31657 int val3 ;
31658 int ecode3 = 0 ;
31659 int val4 ;
31660 int ecode4 = 0 ;
31661 int val5 ;
31662 int ecode5 = 0 ;
31663 PyObject * obj0 = 0 ;
31664 PyObject * obj1 = 0 ;
31665 PyObject * obj2 = 0 ;
31666 PyObject * obj3 = 0 ;
31667 PyObject * obj4 = 0 ;
31668 char * kwnames[] = {
31669 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31670 };
31671
31672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31674 if (!SWIG_IsOK(res1)) {
31675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31676 }
31677 arg1 = reinterpret_cast< wxWindow * >(argp1);
31678 ecode2 = SWIG_AsVal_int(obj1, &val2);
31679 if (!SWIG_IsOK(ecode2)) {
31680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31681 }
31682 arg2 = static_cast< int >(val2);
31683 ecode3 = SWIG_AsVal_int(obj2, &val3);
31684 if (!SWIG_IsOK(ecode3)) {
31685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31686 }
31687 arg3 = static_cast< int >(val3);
31688 if (obj3) {
31689 ecode4 = SWIG_AsVal_int(obj3, &val4);
31690 if (!SWIG_IsOK(ecode4)) {
31691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31692 }
31693 arg4 = static_cast< int >(val4);
31694 }
31695 if (obj4) {
31696 ecode5 = SWIG_AsVal_int(obj4, &val5);
31697 if (!SWIG_IsOK(ecode5)) {
31698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31699 }
31700 arg5 = static_cast< int >(val5);
31701 }
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_Py_Void();
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 wxSize *arg2 = 0 ;
31719 wxSize const &arg3_defvalue = wxDefaultSize ;
31720 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31721 void *argp1 = 0 ;
31722 int res1 = 0 ;
31723 wxSize temp2 ;
31724 wxSize temp3 ;
31725 PyObject * obj0 = 0 ;
31726 PyObject * obj1 = 0 ;
31727 PyObject * obj2 = 0 ;
31728 char * kwnames[] = {
31729 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31730 };
31731
31732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31734 if (!SWIG_IsOK(res1)) {
31735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31736 }
31737 arg1 = reinterpret_cast< wxWindow * >(argp1);
31738 {
31739 arg2 = &temp2;
31740 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31741 }
31742 if (obj2) {
31743 {
31744 arg3 = &temp3;
31745 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31746 }
31747 }
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 resultobj = SWIG_Py_Void();
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31762 PyObject *resultobj = 0;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 wxSize result;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 PyObject *swig_obj[1] ;
31768
31769 if (!args) SWIG_fail;
31770 swig_obj[0] = args;
31771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31772 if (!SWIG_IsOK(res1)) {
31773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31774 }
31775 arg1 = reinterpret_cast< wxWindow * >(argp1);
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = ((wxWindow const *)arg1)->GetMaxSize();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxWindow *arg1 = (wxWindow *) 0 ;
31792 wxSize result;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 PyObject *swig_obj[1] ;
31796
31797 if (!args) SWIG_fail;
31798 swig_obj[0] = args;
31799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31800 if (!SWIG_IsOK(res1)) {
31801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31802 }
31803 arg1 = reinterpret_cast< wxWindow * >(argp1);
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 result = ((wxWindow const *)arg1)->GetMinSize();
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31811 return resultobj;
31812 fail:
31813 return NULL;
31814 }
31815
31816
31817 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31818 PyObject *resultobj = 0;
31819 wxWindow *arg1 = (wxWindow *) 0 ;
31820 wxSize *arg2 = 0 ;
31821 void *argp1 = 0 ;
31822 int res1 = 0 ;
31823 wxSize temp2 ;
31824 PyObject * obj0 = 0 ;
31825 PyObject * obj1 = 0 ;
31826 char * kwnames[] = {
31827 (char *) "self",(char *) "minSize", NULL
31828 };
31829
31830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31834 }
31835 arg1 = reinterpret_cast< wxWindow * >(argp1);
31836 {
31837 arg2 = &temp2;
31838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31839 }
31840 {
31841 PyThreadState* __tstate = wxPyBeginAllowThreads();
31842 (arg1)->SetMinSize((wxSize const &)*arg2);
31843 wxPyEndAllowThreads(__tstate);
31844 if (PyErr_Occurred()) SWIG_fail;
31845 }
31846 resultobj = SWIG_Py_Void();
31847 return resultobj;
31848 fail:
31849 return NULL;
31850 }
31851
31852
31853 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31854 PyObject *resultobj = 0;
31855 wxWindow *arg1 = (wxWindow *) 0 ;
31856 wxSize *arg2 = 0 ;
31857 void *argp1 = 0 ;
31858 int res1 = 0 ;
31859 wxSize temp2 ;
31860 PyObject * obj0 = 0 ;
31861 PyObject * obj1 = 0 ;
31862 char * kwnames[] = {
31863 (char *) "self",(char *) "maxSize", NULL
31864 };
31865
31866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31868 if (!SWIG_IsOK(res1)) {
31869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31870 }
31871 arg1 = reinterpret_cast< wxWindow * >(argp1);
31872 {
31873 arg2 = &temp2;
31874 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31875 }
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 (arg1)->SetMaxSize((wxSize const &)*arg2);
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 resultobj = SWIG_Py_Void();
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31890 PyObject *resultobj = 0;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 int result;
31893 void *argp1 = 0 ;
31894 int res1 = 0 ;
31895 PyObject *swig_obj[1] ;
31896
31897 if (!args) SWIG_fail;
31898 swig_obj[0] = args;
31899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31900 if (!SWIG_IsOK(res1)) {
31901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31902 }
31903 arg1 = reinterpret_cast< wxWindow * >(argp1);
31904 {
31905 PyThreadState* __tstate = wxPyBeginAllowThreads();
31906 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31907 wxPyEndAllowThreads(__tstate);
31908 if (PyErr_Occurred()) SWIG_fail;
31909 }
31910 resultobj = SWIG_From_int(static_cast< int >(result));
31911 return resultobj;
31912 fail:
31913 return NULL;
31914 }
31915
31916
31917 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31918 PyObject *resultobj = 0;
31919 wxWindow *arg1 = (wxWindow *) 0 ;
31920 int result;
31921 void *argp1 = 0 ;
31922 int res1 = 0 ;
31923 PyObject *swig_obj[1] ;
31924
31925 if (!args) SWIG_fail;
31926 swig_obj[0] = args;
31927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31928 if (!SWIG_IsOK(res1)) {
31929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31930 }
31931 arg1 = reinterpret_cast< wxWindow * >(argp1);
31932 {
31933 PyThreadState* __tstate = wxPyBeginAllowThreads();
31934 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31935 wxPyEndAllowThreads(__tstate);
31936 if (PyErr_Occurred()) SWIG_fail;
31937 }
31938 resultobj = SWIG_From_int(static_cast< int >(result));
31939 return resultobj;
31940 fail:
31941 return NULL;
31942 }
31943
31944
31945 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31946 PyObject *resultobj = 0;
31947 wxWindow *arg1 = (wxWindow *) 0 ;
31948 int result;
31949 void *argp1 = 0 ;
31950 int res1 = 0 ;
31951 PyObject *swig_obj[1] ;
31952
31953 if (!args) SWIG_fail;
31954 swig_obj[0] = args;
31955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31956 if (!SWIG_IsOK(res1)) {
31957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31958 }
31959 arg1 = reinterpret_cast< wxWindow * >(argp1);
31960 {
31961 PyThreadState* __tstate = wxPyBeginAllowThreads();
31962 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31963 wxPyEndAllowThreads(__tstate);
31964 if (PyErr_Occurred()) SWIG_fail;
31965 }
31966 resultobj = SWIG_From_int(static_cast< int >(result));
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *resultobj = 0;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 int result;
31977 void *argp1 = 0 ;
31978 int res1 = 0 ;
31979 PyObject *swig_obj[1] ;
31980
31981 if (!args) SWIG_fail;
31982 swig_obj[0] = args;
31983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 PyThreadState* __tstate = wxPyBeginAllowThreads();
31990 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_From_int(static_cast< int >(result));
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32002 PyObject *resultobj = 0;
32003 wxWindow *arg1 = (wxWindow *) 0 ;
32004 wxSize *arg2 = 0 ;
32005 void *argp1 = 0 ;
32006 int res1 = 0 ;
32007 wxSize temp2 ;
32008 PyObject * obj0 = 0 ;
32009 PyObject * obj1 = 0 ;
32010 char * kwnames[] = {
32011 (char *) "self",(char *) "size", NULL
32012 };
32013
32014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32016 if (!SWIG_IsOK(res1)) {
32017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32018 }
32019 arg1 = reinterpret_cast< wxWindow * >(argp1);
32020 {
32021 arg2 = &temp2;
32022 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32023 }
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_Py_Void();
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 int arg2 ;
32041 int arg3 ;
32042 void *argp1 = 0 ;
32043 int res1 = 0 ;
32044 int val2 ;
32045 int ecode2 = 0 ;
32046 int val3 ;
32047 int ecode3 = 0 ;
32048 PyObject * obj0 = 0 ;
32049 PyObject * obj1 = 0 ;
32050 PyObject * obj2 = 0 ;
32051 char * kwnames[] = {
32052 (char *) "self",(char *) "w",(char *) "h", NULL
32053 };
32054
32055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32057 if (!SWIG_IsOK(res1)) {
32058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32059 }
32060 arg1 = reinterpret_cast< wxWindow * >(argp1);
32061 ecode2 = SWIG_AsVal_int(obj1, &val2);
32062 if (!SWIG_IsOK(ecode2)) {
32063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32064 }
32065 arg2 = static_cast< int >(val2);
32066 ecode3 = SWIG_AsVal_int(obj2, &val3);
32067 if (!SWIG_IsOK(ecode3)) {
32068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32069 }
32070 arg3 = static_cast< int >(val3);
32071 {
32072 PyThreadState* __tstate = wxPyBeginAllowThreads();
32073 (arg1)->SetVirtualSize(arg2,arg3);
32074 wxPyEndAllowThreads(__tstate);
32075 if (PyErr_Occurred()) SWIG_fail;
32076 }
32077 resultobj = SWIG_Py_Void();
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *resultobj = 0;
32086 wxWindow *arg1 = (wxWindow *) 0 ;
32087 wxSize result;
32088 void *argp1 = 0 ;
32089 int res1 = 0 ;
32090 PyObject *swig_obj[1] ;
32091
32092 if (!args) SWIG_fail;
32093 swig_obj[0] = args;
32094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32095 if (!SWIG_IsOK(res1)) {
32096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32097 }
32098 arg1 = reinterpret_cast< wxWindow * >(argp1);
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 result = ((wxWindow const *)arg1)->GetVirtualSize();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 wxWindow *arg1 = (wxWindow *) 0 ;
32115 int *arg2 = (int *) 0 ;
32116 int *arg3 = (int *) 0 ;
32117 void *argp1 = 0 ;
32118 int res1 = 0 ;
32119 int temp2 ;
32120 int res2 = SWIG_TMPOBJ ;
32121 int temp3 ;
32122 int res3 = SWIG_TMPOBJ ;
32123 PyObject *swig_obj[1] ;
32124
32125 arg2 = &temp2;
32126 arg3 = &temp3;
32127 if (!args) SWIG_fail;
32128 swig_obj[0] = args;
32129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32130 if (!SWIG_IsOK(res1)) {
32131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32132 }
32133 arg1 = reinterpret_cast< wxWindow * >(argp1);
32134 {
32135 PyThreadState* __tstate = wxPyBeginAllowThreads();
32136 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32137 wxPyEndAllowThreads(__tstate);
32138 if (PyErr_Occurred()) SWIG_fail;
32139 }
32140 resultobj = SWIG_Py_Void();
32141 if (SWIG_IsTmpObj(res2)) {
32142 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32143 } else {
32144 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32146 }
32147 if (SWIG_IsTmpObj(res3)) {
32148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32149 } else {
32150 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32152 }
32153 return resultobj;
32154 fail:
32155 return NULL;
32156 }
32157
32158
32159 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32160 PyObject *resultobj = 0;
32161 wxWindow *arg1 = (wxWindow *) 0 ;
32162 wxSize 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_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32177 wxPyEndAllowThreads(__tstate);
32178 if (PyErr_Occurred()) SWIG_fail;
32179 }
32180 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32181 return resultobj;
32182 fail:
32183 return NULL;
32184 }
32185
32186
32187 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32188 PyObject *resultobj = 0;
32189 wxWindow *arg1 = (wxWindow *) 0 ;
32190 bool arg2 = (bool) true ;
32191 bool result;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 bool val2 ;
32195 int ecode2 = 0 ;
32196 PyObject * obj0 = 0 ;
32197 PyObject * obj1 = 0 ;
32198 char * kwnames[] = {
32199 (char *) "self",(char *) "show", NULL
32200 };
32201
32202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32204 if (!SWIG_IsOK(res1)) {
32205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32206 }
32207 arg1 = reinterpret_cast< wxWindow * >(argp1);
32208 if (obj1) {
32209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32210 if (!SWIG_IsOK(ecode2)) {
32211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32212 }
32213 arg2 = static_cast< bool >(val2);
32214 }
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (bool)(arg1)->Show(arg2);
32218 wxPyEndAllowThreads(__tstate);
32219 if (PyErr_Occurred()) SWIG_fail;
32220 }
32221 {
32222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32223 }
32224 return resultobj;
32225 fail:
32226 return NULL;
32227 }
32228
32229
32230 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32231 PyObject *resultobj = 0;
32232 wxWindow *arg1 = (wxWindow *) 0 ;
32233 bool result;
32234 void *argp1 = 0 ;
32235 int res1 = 0 ;
32236 PyObject *swig_obj[1] ;
32237
32238 if (!args) SWIG_fail;
32239 swig_obj[0] = args;
32240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32243 }
32244 arg1 = reinterpret_cast< wxWindow * >(argp1);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)(arg1)->Hide();
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32261 PyObject *resultobj = 0;
32262 wxWindow *arg1 = (wxWindow *) 0 ;
32263 bool arg2 = (bool) true ;
32264 bool result;
32265 void *argp1 = 0 ;
32266 int res1 = 0 ;
32267 bool val2 ;
32268 int ecode2 = 0 ;
32269 PyObject * obj0 = 0 ;
32270 PyObject * obj1 = 0 ;
32271 char * kwnames[] = {
32272 (char *) "self",(char *) "enable", NULL
32273 };
32274
32275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32277 if (!SWIG_IsOK(res1)) {
32278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32279 }
32280 arg1 = reinterpret_cast< wxWindow * >(argp1);
32281 if (obj1) {
32282 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32283 if (!SWIG_IsOK(ecode2)) {
32284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32285 }
32286 arg2 = static_cast< bool >(val2);
32287 }
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (bool)(arg1)->Enable(arg2);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 {
32295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32296 }
32297 return resultobj;
32298 fail:
32299 return NULL;
32300 }
32301
32302
32303 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32304 PyObject *resultobj = 0;
32305 wxWindow *arg1 = (wxWindow *) 0 ;
32306 bool result;
32307 void *argp1 = 0 ;
32308 int res1 = 0 ;
32309 PyObject *swig_obj[1] ;
32310
32311 if (!args) SWIG_fail;
32312 swig_obj[0] = args;
32313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32314 if (!SWIG_IsOK(res1)) {
32315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32316 }
32317 arg1 = reinterpret_cast< wxWindow * >(argp1);
32318 {
32319 PyThreadState* __tstate = wxPyBeginAllowThreads();
32320 result = (bool)(arg1)->Disable();
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 {
32325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32326 }
32327 return resultobj;
32328 fail:
32329 return NULL;
32330 }
32331
32332
32333 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32334 PyObject *resultobj = 0;
32335 wxWindow *arg1 = (wxWindow *) 0 ;
32336 bool result;
32337 void *argp1 = 0 ;
32338 int res1 = 0 ;
32339 PyObject *swig_obj[1] ;
32340
32341 if (!args) SWIG_fail;
32342 swig_obj[0] = args;
32343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32344 if (!SWIG_IsOK(res1)) {
32345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32346 }
32347 arg1 = reinterpret_cast< wxWindow * >(argp1);
32348 {
32349 PyThreadState* __tstate = wxPyBeginAllowThreads();
32350 result = (bool)((wxWindow const *)arg1)->IsShown();
32351 wxPyEndAllowThreads(__tstate);
32352 if (PyErr_Occurred()) SWIG_fail;
32353 }
32354 {
32355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32356 }
32357 return resultobj;
32358 fail:
32359 return NULL;
32360 }
32361
32362
32363 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32364 PyObject *resultobj = 0;
32365 wxWindow *arg1 = (wxWindow *) 0 ;
32366 bool result;
32367 void *argp1 = 0 ;
32368 int res1 = 0 ;
32369 PyObject *swig_obj[1] ;
32370
32371 if (!args) SWIG_fail;
32372 swig_obj[0] = args;
32373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32374 if (!SWIG_IsOK(res1)) {
32375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32376 }
32377 arg1 = reinterpret_cast< wxWindow * >(argp1);
32378 {
32379 PyThreadState* __tstate = wxPyBeginAllowThreads();
32380 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32381 wxPyEndAllowThreads(__tstate);
32382 if (PyErr_Occurred()) SWIG_fail;
32383 }
32384 {
32385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32386 }
32387 return resultobj;
32388 fail:
32389 return NULL;
32390 }
32391
32392
32393 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32394 PyObject *resultobj = 0;
32395 wxWindow *arg1 = (wxWindow *) 0 ;
32396 long arg2 ;
32397 void *argp1 = 0 ;
32398 int res1 = 0 ;
32399 long val2 ;
32400 int ecode2 = 0 ;
32401 PyObject * obj0 = 0 ;
32402 PyObject * obj1 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "self",(char *) "style", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32411 }
32412 arg1 = reinterpret_cast< wxWindow * >(argp1);
32413 ecode2 = SWIG_AsVal_long(obj1, &val2);
32414 if (!SWIG_IsOK(ecode2)) {
32415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32416 }
32417 arg2 = static_cast< long >(val2);
32418 {
32419 PyThreadState* __tstate = wxPyBeginAllowThreads();
32420 (arg1)->SetWindowStyleFlag(arg2);
32421 wxPyEndAllowThreads(__tstate);
32422 if (PyErr_Occurred()) SWIG_fail;
32423 }
32424 resultobj = SWIG_Py_Void();
32425 return resultobj;
32426 fail:
32427 return NULL;
32428 }
32429
32430
32431 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32432 PyObject *resultobj = 0;
32433 wxWindow *arg1 = (wxWindow *) 0 ;
32434 long result;
32435 void *argp1 = 0 ;
32436 int res1 = 0 ;
32437 PyObject *swig_obj[1] ;
32438
32439 if (!args) SWIG_fail;
32440 swig_obj[0] = args;
32441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32442 if (!SWIG_IsOK(res1)) {
32443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32444 }
32445 arg1 = reinterpret_cast< wxWindow * >(argp1);
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32449 wxPyEndAllowThreads(__tstate);
32450 if (PyErr_Occurred()) SWIG_fail;
32451 }
32452 resultobj = SWIG_From_long(static_cast< long >(result));
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32460 PyObject *resultobj = 0;
32461 wxWindow *arg1 = (wxWindow *) 0 ;
32462 int arg2 ;
32463 bool result;
32464 void *argp1 = 0 ;
32465 int res1 = 0 ;
32466 int val2 ;
32467 int ecode2 = 0 ;
32468 PyObject * obj0 = 0 ;
32469 PyObject * obj1 = 0 ;
32470 char * kwnames[] = {
32471 (char *) "self",(char *) "flag", NULL
32472 };
32473
32474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32476 if (!SWIG_IsOK(res1)) {
32477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32478 }
32479 arg1 = reinterpret_cast< wxWindow * >(argp1);
32480 ecode2 = SWIG_AsVal_int(obj1, &val2);
32481 if (!SWIG_IsOK(ecode2)) {
32482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32483 }
32484 arg2 = static_cast< int >(val2);
32485 {
32486 PyThreadState* __tstate = wxPyBeginAllowThreads();
32487 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 {
32492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32493 }
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32501 PyObject *resultobj = 0;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 bool result;
32504 void *argp1 = 0 ;
32505 int res1 = 0 ;
32506 PyObject *swig_obj[1] ;
32507
32508 if (!args) SWIG_fail;
32509 swig_obj[0] = args;
32510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32511 if (!SWIG_IsOK(res1)) {
32512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32513 }
32514 arg1 = reinterpret_cast< wxWindow * >(argp1);
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (bool)((wxWindow const *)arg1)->IsRetained();
32518 wxPyEndAllowThreads(__tstate);
32519 if (PyErr_Occurred()) SWIG_fail;
32520 }
32521 {
32522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32523 }
32524 return resultobj;
32525 fail:
32526 return NULL;
32527 }
32528
32529
32530 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32531 PyObject *resultobj = 0;
32532 wxWindow *arg1 = (wxWindow *) 0 ;
32533 long arg2 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 long val2 ;
32537 int ecode2 = 0 ;
32538 PyObject * obj0 = 0 ;
32539 PyObject * obj1 = 0 ;
32540 char * kwnames[] = {
32541 (char *) "self",(char *) "exStyle", NULL
32542 };
32543
32544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32546 if (!SWIG_IsOK(res1)) {
32547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32548 }
32549 arg1 = reinterpret_cast< wxWindow * >(argp1);
32550 ecode2 = SWIG_AsVal_long(obj1, &val2);
32551 if (!SWIG_IsOK(ecode2)) {
32552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32553 }
32554 arg2 = static_cast< long >(val2);
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 (arg1)->SetExtraStyle(arg2);
32558 wxPyEndAllowThreads(__tstate);
32559 if (PyErr_Occurred()) SWIG_fail;
32560 }
32561 resultobj = SWIG_Py_Void();
32562 return resultobj;
32563 fail:
32564 return NULL;
32565 }
32566
32567
32568 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32569 PyObject *resultobj = 0;
32570 wxWindow *arg1 = (wxWindow *) 0 ;
32571 long result;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 PyObject *swig_obj[1] ;
32575
32576 if (!args) SWIG_fail;
32577 swig_obj[0] = args;
32578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32579 if (!SWIG_IsOK(res1)) {
32580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32581 }
32582 arg1 = reinterpret_cast< wxWindow * >(argp1);
32583 {
32584 PyThreadState* __tstate = wxPyBeginAllowThreads();
32585 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32586 wxPyEndAllowThreads(__tstate);
32587 if (PyErr_Occurred()) SWIG_fail;
32588 }
32589 resultobj = SWIG_From_long(static_cast< long >(result));
32590 return resultobj;
32591 fail:
32592 return NULL;
32593 }
32594
32595
32596 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32597 PyObject *resultobj = 0;
32598 wxWindow *arg1 = (wxWindow *) 0 ;
32599 bool arg2 = (bool) true ;
32600 void *argp1 = 0 ;
32601 int res1 = 0 ;
32602 bool val2 ;
32603 int ecode2 = 0 ;
32604 PyObject * obj0 = 0 ;
32605 PyObject * obj1 = 0 ;
32606 char * kwnames[] = {
32607 (char *) "self",(char *) "modal", NULL
32608 };
32609
32610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32612 if (!SWIG_IsOK(res1)) {
32613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32614 }
32615 arg1 = reinterpret_cast< wxWindow * >(argp1);
32616 if (obj1) {
32617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32618 if (!SWIG_IsOK(ecode2)) {
32619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32620 }
32621 arg2 = static_cast< bool >(val2);
32622 }
32623 {
32624 PyThreadState* __tstate = wxPyBeginAllowThreads();
32625 (arg1)->MakeModal(arg2);
32626 wxPyEndAllowThreads(__tstate);
32627 if (PyErr_Occurred()) SWIG_fail;
32628 }
32629 resultobj = SWIG_Py_Void();
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32637 PyObject *resultobj = 0;
32638 wxWindow *arg1 = (wxWindow *) 0 ;
32639 bool arg2 ;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 bool val2 ;
32643 int ecode2 = 0 ;
32644 PyObject * obj0 = 0 ;
32645 PyObject * obj1 = 0 ;
32646 char * kwnames[] = {
32647 (char *) "self",(char *) "enableTheme", NULL
32648 };
32649
32650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32654 }
32655 arg1 = reinterpret_cast< wxWindow * >(argp1);
32656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32657 if (!SWIG_IsOK(ecode2)) {
32658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32659 }
32660 arg2 = static_cast< bool >(val2);
32661 {
32662 PyThreadState* __tstate = wxPyBeginAllowThreads();
32663 (arg1)->SetThemeEnabled(arg2);
32664 wxPyEndAllowThreads(__tstate);
32665 if (PyErr_Occurred()) SWIG_fail;
32666 }
32667 resultobj = SWIG_Py_Void();
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *resultobj = 0;
32676 wxWindow *arg1 = (wxWindow *) 0 ;
32677 bool result;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 PyObject *swig_obj[1] ;
32681
32682 if (!args) SWIG_fail;
32683 swig_obj[0] = args;
32684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32687 }
32688 arg1 = reinterpret_cast< wxWindow * >(argp1);
32689 {
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32692 wxPyEndAllowThreads(__tstate);
32693 if (PyErr_Occurred()) SWIG_fail;
32694 }
32695 {
32696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32697 }
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *resultobj = 0;
32706 wxWindow *arg1 = (wxWindow *) 0 ;
32707 void *argp1 = 0 ;
32708 int res1 = 0 ;
32709 PyObject *swig_obj[1] ;
32710
32711 if (!args) SWIG_fail;
32712 swig_obj[0] = args;
32713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32716 }
32717 arg1 = reinterpret_cast< wxWindow * >(argp1);
32718 {
32719 PyThreadState* __tstate = wxPyBeginAllowThreads();
32720 (arg1)->SetFocus();
32721 wxPyEndAllowThreads(__tstate);
32722 if (PyErr_Occurred()) SWIG_fail;
32723 }
32724 resultobj = SWIG_Py_Void();
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32732 PyObject *resultobj = 0;
32733 wxWindow *arg1 = (wxWindow *) 0 ;
32734 void *argp1 = 0 ;
32735 int res1 = 0 ;
32736 PyObject *swig_obj[1] ;
32737
32738 if (!args) SWIG_fail;
32739 swig_obj[0] = args;
32740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32741 if (!SWIG_IsOK(res1)) {
32742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32743 }
32744 arg1 = reinterpret_cast< wxWindow * >(argp1);
32745 {
32746 PyThreadState* __tstate = wxPyBeginAllowThreads();
32747 (arg1)->SetFocusFromKbd();
32748 wxPyEndAllowThreads(__tstate);
32749 if (PyErr_Occurred()) SWIG_fail;
32750 }
32751 resultobj = SWIG_Py_Void();
32752 return resultobj;
32753 fail:
32754 return NULL;
32755 }
32756
32757
32758 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32759 PyObject *resultobj = 0;
32760 wxWindow *result = 0 ;
32761
32762 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32763 {
32764 if (!wxPyCheckForApp()) SWIG_fail;
32765 PyThreadState* __tstate = wxPyBeginAllowThreads();
32766 result = (wxWindow *)wxWindow::FindFocus();
32767 wxPyEndAllowThreads(__tstate);
32768 if (PyErr_Occurred()) SWIG_fail;
32769 }
32770 {
32771 resultobj = wxPyMake_wxObject(result, 0);
32772 }
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 bool result;
32783 void *argp1 = 0 ;
32784 int res1 = 0 ;
32785 PyObject *swig_obj[1] ;
32786
32787 if (!args) SWIG_fail;
32788 swig_obj[0] = args;
32789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 {
32795 PyThreadState* __tstate = wxPyBeginAllowThreads();
32796 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32797 wxPyEndAllowThreads(__tstate);
32798 if (PyErr_Occurred()) SWIG_fail;
32799 }
32800 {
32801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32802 }
32803 return resultobj;
32804 fail:
32805 return NULL;
32806 }
32807
32808
32809 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32810 PyObject *resultobj = 0;
32811 wxWindow *arg1 = (wxWindow *) 0 ;
32812 bool result;
32813 void *argp1 = 0 ;
32814 int res1 = 0 ;
32815 PyObject *swig_obj[1] ;
32816
32817 if (!args) SWIG_fail;
32818 swig_obj[0] = args;
32819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32820 if (!SWIG_IsOK(res1)) {
32821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32822 }
32823 arg1 = reinterpret_cast< wxWindow * >(argp1);
32824 {
32825 PyThreadState* __tstate = wxPyBeginAllowThreads();
32826 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32827 wxPyEndAllowThreads(__tstate);
32828 if (PyErr_Occurred()) SWIG_fail;
32829 }
32830 {
32831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32832 }
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32840 PyObject *resultobj = 0;
32841 wxWindow *arg1 = (wxWindow *) 0 ;
32842 wxWindow *result = 0 ;
32843 void *argp1 = 0 ;
32844 int res1 = 0 ;
32845 PyObject *swig_obj[1] ;
32846
32847 if (!args) SWIG_fail;
32848 swig_obj[0] = args;
32849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32850 if (!SWIG_IsOK(res1)) {
32851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32852 }
32853 arg1 = reinterpret_cast< wxWindow * >(argp1);
32854 {
32855 PyThreadState* __tstate = wxPyBeginAllowThreads();
32856 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32857 wxPyEndAllowThreads(__tstate);
32858 if (PyErr_Occurred()) SWIG_fail;
32859 }
32860 {
32861 resultobj = wxPyMake_wxObject(result, 0);
32862 }
32863 return resultobj;
32864 fail:
32865 return NULL;
32866 }
32867
32868
32869 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32870 PyObject *resultobj = 0;
32871 wxWindow *arg1 = (wxWindow *) 0 ;
32872 wxWindow *arg2 = (wxWindow *) 0 ;
32873 wxWindow *result = 0 ;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 void *argp2 = 0 ;
32877 int res2 = 0 ;
32878 PyObject * obj0 = 0 ;
32879 PyObject * obj1 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "self",(char *) "child", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32888 }
32889 arg1 = reinterpret_cast< wxWindow * >(argp1);
32890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32891 if (!SWIG_IsOK(res2)) {
32892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32893 }
32894 arg2 = reinterpret_cast< wxWindow * >(argp2);
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 {
32902 resultobj = wxPyMake_wxObject(result, 0);
32903 }
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 wxWindow *arg2 = (wxWindow *) 0 ;
32914 void *argp1 = 0 ;
32915 int res1 = 0 ;
32916 void *argp2 = 0 ;
32917 int res2 = 0 ;
32918 PyObject * obj0 = 0 ;
32919 PyObject * obj1 = 0 ;
32920 char * kwnames[] = {
32921 (char *) "self",(char *) "win", NULL
32922 };
32923
32924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32928 }
32929 arg1 = reinterpret_cast< wxWindow * >(argp1);
32930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32931 if (!SWIG_IsOK(res2)) {
32932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32933 }
32934 arg2 = reinterpret_cast< wxWindow * >(argp2);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 (arg1)->SetTmpDefaultItem(arg2);
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 resultobj = SWIG_Py_Void();
32942 return resultobj;
32943 fail:
32944 return NULL;
32945 }
32946
32947
32948 SWIGINTERN PyObject *_wrap_Window_GetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32949 PyObject *resultobj = 0;
32950 wxWindow *arg1 = (wxWindow *) 0 ;
32951 wxWindow *result = 0 ;
32952 void *argp1 = 0 ;
32953 int res1 = 0 ;
32954 PyObject *swig_obj[1] ;
32955
32956 if (!args) SWIG_fail;
32957 swig_obj[0] = args;
32958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32959 if (!SWIG_IsOK(res1)) {
32960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32961 }
32962 arg1 = reinterpret_cast< wxWindow * >(argp1);
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (wxWindow *)((wxWindow const *)arg1)->GetTmpDefaultItem();
32966 wxPyEndAllowThreads(__tstate);
32967 if (PyErr_Occurred()) SWIG_fail;
32968 }
32969 {
32970 resultobj = wxPyMake_wxObject(result, 0);
32971 }
32972 return resultobj;
32973 fail:
32974 return NULL;
32975 }
32976
32977
32978 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32979 PyObject *resultobj = 0;
32980 wxWindow *arg1 = (wxWindow *) 0 ;
32981 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32982 bool result;
32983 void *argp1 = 0 ;
32984 int res1 = 0 ;
32985 int val2 ;
32986 int ecode2 = 0 ;
32987 PyObject * obj0 = 0 ;
32988 PyObject * obj1 = 0 ;
32989 char * kwnames[] = {
32990 (char *) "self",(char *) "flags", NULL
32991 };
32992
32993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32995 if (!SWIG_IsOK(res1)) {
32996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32997 }
32998 arg1 = reinterpret_cast< wxWindow * >(argp1);
32999 if (obj1) {
33000 ecode2 = SWIG_AsVal_int(obj1, &val2);
33001 if (!SWIG_IsOK(ecode2)) {
33002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33003 }
33004 arg2 = static_cast< int >(val2);
33005 }
33006 {
33007 PyThreadState* __tstate = wxPyBeginAllowThreads();
33008 result = (bool)(arg1)->Navigate(arg2);
33009 wxPyEndAllowThreads(__tstate);
33010 if (PyErr_Occurred()) SWIG_fail;
33011 }
33012 {
33013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33014 }
33015 return resultobj;
33016 fail:
33017 return NULL;
33018 }
33019
33020
33021 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33022 PyObject *resultobj = 0;
33023 wxWindow *arg1 = (wxWindow *) 0 ;
33024 wxWindow *arg2 = (wxWindow *) 0 ;
33025 void *argp1 = 0 ;
33026 int res1 = 0 ;
33027 void *argp2 = 0 ;
33028 int res2 = 0 ;
33029 PyObject * obj0 = 0 ;
33030 PyObject * obj1 = 0 ;
33031 char * kwnames[] = {
33032 (char *) "self",(char *) "win", NULL
33033 };
33034
33035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33037 if (!SWIG_IsOK(res1)) {
33038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33039 }
33040 arg1 = reinterpret_cast< wxWindow * >(argp1);
33041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33042 if (!SWIG_IsOK(res2)) {
33043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33044 }
33045 arg2 = reinterpret_cast< wxWindow * >(argp2);
33046 {
33047 PyThreadState* __tstate = wxPyBeginAllowThreads();
33048 (arg1)->MoveAfterInTabOrder(arg2);
33049 wxPyEndAllowThreads(__tstate);
33050 if (PyErr_Occurred()) SWIG_fail;
33051 }
33052 resultobj = SWIG_Py_Void();
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33060 PyObject *resultobj = 0;
33061 wxWindow *arg1 = (wxWindow *) 0 ;
33062 wxWindow *arg2 = (wxWindow *) 0 ;
33063 void *argp1 = 0 ;
33064 int res1 = 0 ;
33065 void *argp2 = 0 ;
33066 int res2 = 0 ;
33067 PyObject * obj0 = 0 ;
33068 PyObject * obj1 = 0 ;
33069 char * kwnames[] = {
33070 (char *) "self",(char *) "win", NULL
33071 };
33072
33073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33075 if (!SWIG_IsOK(res1)) {
33076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33077 }
33078 arg1 = reinterpret_cast< wxWindow * >(argp1);
33079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res2)) {
33081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33082 }
33083 arg2 = reinterpret_cast< wxWindow * >(argp2);
33084 {
33085 PyThreadState* __tstate = wxPyBeginAllowThreads();
33086 (arg1)->MoveBeforeInTabOrder(arg2);
33087 wxPyEndAllowThreads(__tstate);
33088 if (PyErr_Occurred()) SWIG_fail;
33089 }
33090 resultobj = SWIG_Py_Void();
33091 return resultobj;
33092 fail:
33093 return NULL;
33094 }
33095
33096
33097 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33098 PyObject *resultobj = 0;
33099 wxWindow *arg1 = (wxWindow *) 0 ;
33100 PyObject *result = 0 ;
33101 void *argp1 = 0 ;
33102 int res1 = 0 ;
33103 PyObject *swig_obj[1] ;
33104
33105 if (!args) SWIG_fail;
33106 swig_obj[0] = args;
33107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33108 if (!SWIG_IsOK(res1)) {
33109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33110 }
33111 arg1 = reinterpret_cast< wxWindow * >(argp1);
33112 {
33113 PyThreadState* __tstate = wxPyBeginAllowThreads();
33114 result = (PyObject *)wxWindow_GetChildren(arg1);
33115 wxPyEndAllowThreads(__tstate);
33116 if (PyErr_Occurred()) SWIG_fail;
33117 }
33118 resultobj = result;
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxWindow *result = 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 PyObject *swig_obj[1] ;
33132
33133 if (!args) SWIG_fail;
33134 swig_obj[0] = args;
33135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33138 }
33139 arg1 = reinterpret_cast< wxWindow * >(argp1);
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 wxWindow *result = 0 ;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 PyObject *swig_obj[1] ;
33162
33163 if (!args) SWIG_fail;
33164 swig_obj[0] = args;
33165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33166 if (!SWIG_IsOK(res1)) {
33167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33168 }
33169 arg1 = reinterpret_cast< wxWindow * >(argp1);
33170 {
33171 PyThreadState* __tstate = wxPyBeginAllowThreads();
33172 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 {
33177 resultobj = wxPyMake_wxObject(result, 0);
33178 }
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33186 PyObject *resultobj = 0;
33187 wxWindow *arg1 = (wxWindow *) 0 ;
33188 bool result;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 PyObject *swig_obj[1] ;
33192
33193 if (!args) SWIG_fail;
33194 swig_obj[0] = args;
33195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33196 if (!SWIG_IsOK(res1)) {
33197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33198 }
33199 arg1 = reinterpret_cast< wxWindow * >(argp1);
33200 {
33201 PyThreadState* __tstate = wxPyBeginAllowThreads();
33202 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 {
33207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33208 }
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33216 PyObject *resultobj = 0;
33217 wxWindow *arg1 = (wxWindow *) 0 ;
33218 wxWindow *arg2 = (wxWindow *) 0 ;
33219 bool result;
33220 void *argp1 = 0 ;
33221 int res1 = 0 ;
33222 void *argp2 = 0 ;
33223 int res2 = 0 ;
33224 PyObject * obj0 = 0 ;
33225 PyObject * obj1 = 0 ;
33226 char * kwnames[] = {
33227 (char *) "self",(char *) "newParent", NULL
33228 };
33229
33230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33232 if (!SWIG_IsOK(res1)) {
33233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33234 }
33235 arg1 = reinterpret_cast< wxWindow * >(argp1);
33236 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33237 if (!SWIG_IsOK(res2)) {
33238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33239 }
33240 arg2 = reinterpret_cast< wxWindow * >(argp2);
33241 {
33242 PyThreadState* __tstate = wxPyBeginAllowThreads();
33243 result = (bool)(arg1)->Reparent(arg2);
33244 wxPyEndAllowThreads(__tstate);
33245 if (PyErr_Occurred()) SWIG_fail;
33246 }
33247 {
33248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33249 }
33250 return resultobj;
33251 fail:
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33257 PyObject *resultobj = 0;
33258 wxWindow *arg1 = (wxWindow *) 0 ;
33259 wxWindow *arg2 = (wxWindow *) 0 ;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 void *argp2 = 0 ;
33263 int res2 = 0 ;
33264 PyObject * obj0 = 0 ;
33265 PyObject * obj1 = 0 ;
33266 char * kwnames[] = {
33267 (char *) "self",(char *) "child", NULL
33268 };
33269
33270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33274 }
33275 arg1 = reinterpret_cast< wxWindow * >(argp1);
33276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res2)) {
33278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33279 }
33280 arg2 = reinterpret_cast< wxWindow * >(argp2);
33281 {
33282 PyThreadState* __tstate = wxPyBeginAllowThreads();
33283 (arg1)->AddChild(arg2);
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 resultobj = SWIG_Py_Void();
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33295 PyObject *resultobj = 0;
33296 wxWindow *arg1 = (wxWindow *) 0 ;
33297 wxWindow *arg2 = (wxWindow *) 0 ;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 void *argp2 = 0 ;
33301 int res2 = 0 ;
33302 PyObject * obj0 = 0 ;
33303 PyObject * obj1 = 0 ;
33304 char * kwnames[] = {
33305 (char *) "self",(char *) "child", NULL
33306 };
33307
33308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33312 }
33313 arg1 = reinterpret_cast< wxWindow * >(argp1);
33314 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33315 if (!SWIG_IsOK(res2)) {
33316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33317 }
33318 arg2 = reinterpret_cast< wxWindow * >(argp2);
33319 {
33320 PyThreadState* __tstate = wxPyBeginAllowThreads();
33321 (arg1)->RemoveChild(arg2);
33322 wxPyEndAllowThreads(__tstate);
33323 if (PyErr_Occurred()) SWIG_fail;
33324 }
33325 resultobj = SWIG_Py_Void();
33326 return resultobj;
33327 fail:
33328 return NULL;
33329 }
33330
33331
33332 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33333 PyObject *resultobj = 0;
33334 wxWindow *arg1 = (wxWindow *) 0 ;
33335 bool arg2 ;
33336 void *argp1 = 0 ;
33337 int res1 = 0 ;
33338 bool val2 ;
33339 int ecode2 = 0 ;
33340 PyObject * obj0 = 0 ;
33341 PyObject * obj1 = 0 ;
33342 char * kwnames[] = {
33343 (char *) "self",(char *) "on", NULL
33344 };
33345
33346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33348 if (!SWIG_IsOK(res1)) {
33349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33350 }
33351 arg1 = reinterpret_cast< wxWindow * >(argp1);
33352 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33353 if (!SWIG_IsOK(ecode2)) {
33354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33355 }
33356 arg2 = static_cast< bool >(val2);
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 wxWindow_SetDoubleBuffered(arg1,arg2);
33360 wxPyEndAllowThreads(__tstate);
33361 if (PyErr_Occurred()) SWIG_fail;
33362 }
33363 resultobj = SWIG_Py_Void();
33364 return resultobj;
33365 fail:
33366 return NULL;
33367 }
33368
33369
33370 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33371 PyObject *resultobj = 0;
33372 wxWindow *arg1 = (wxWindow *) 0 ;
33373 long arg2 ;
33374 wxWindow *result = 0 ;
33375 void *argp1 = 0 ;
33376 int res1 = 0 ;
33377 long val2 ;
33378 int ecode2 = 0 ;
33379 PyObject * obj0 = 0 ;
33380 PyObject * obj1 = 0 ;
33381 char * kwnames[] = {
33382 (char *) "self",(char *) "winid", NULL
33383 };
33384
33385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33387 if (!SWIG_IsOK(res1)) {
33388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33389 }
33390 arg1 = reinterpret_cast< wxWindow * >(argp1);
33391 ecode2 = SWIG_AsVal_long(obj1, &val2);
33392 if (!SWIG_IsOK(ecode2)) {
33393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33394 }
33395 arg2 = static_cast< long >(val2);
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 result = (wxWindow *)(arg1)->FindWindow(arg2);
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 {
33403 resultobj = wxPyMake_wxObject(result, 0);
33404 }
33405 return resultobj;
33406 fail:
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33412 PyObject *resultobj = 0;
33413 wxWindow *arg1 = (wxWindow *) 0 ;
33414 wxString *arg2 = 0 ;
33415 wxWindow *result = 0 ;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 bool temp2 = false ;
33419 PyObject * obj0 = 0 ;
33420 PyObject * obj1 = 0 ;
33421 char * kwnames[] = {
33422 (char *) "self",(char *) "name", NULL
33423 };
33424
33425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33427 if (!SWIG_IsOK(res1)) {
33428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33429 }
33430 arg1 = reinterpret_cast< wxWindow * >(argp1);
33431 {
33432 arg2 = wxString_in_helper(obj1);
33433 if (arg2 == NULL) SWIG_fail;
33434 temp2 = true;
33435 }
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 {
33443 resultobj = wxPyMake_wxObject(result, 0);
33444 }
33445 {
33446 if (temp2)
33447 delete arg2;
33448 }
33449 return resultobj;
33450 fail:
33451 {
33452 if (temp2)
33453 delete arg2;
33454 }
33455 return NULL;
33456 }
33457
33458
33459 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33460 PyObject *resultobj = 0;
33461 wxWindow *arg1 = (wxWindow *) 0 ;
33462 wxEvtHandler *result = 0 ;
33463 void *argp1 = 0 ;
33464 int res1 = 0 ;
33465 PyObject *swig_obj[1] ;
33466
33467 if (!args) SWIG_fail;
33468 swig_obj[0] = args;
33469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33470 if (!SWIG_IsOK(res1)) {
33471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33472 }
33473 arg1 = reinterpret_cast< wxWindow * >(argp1);
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33477 wxPyEndAllowThreads(__tstate);
33478 if (PyErr_Occurred()) SWIG_fail;
33479 }
33480 {
33481 resultobj = wxPyMake_wxObject(result, 0);
33482 }
33483 return resultobj;
33484 fail:
33485 return NULL;
33486 }
33487
33488
33489 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33490 PyObject *resultobj = 0;
33491 wxWindow *arg1 = (wxWindow *) 0 ;
33492 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33493 void *argp1 = 0 ;
33494 int res1 = 0 ;
33495 void *argp2 = 0 ;
33496 int res2 = 0 ;
33497 PyObject * obj0 = 0 ;
33498 PyObject * obj1 = 0 ;
33499 char * kwnames[] = {
33500 (char *) "self",(char *) "handler", NULL
33501 };
33502
33503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33505 if (!SWIG_IsOK(res1)) {
33506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33507 }
33508 arg1 = reinterpret_cast< wxWindow * >(argp1);
33509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33510 if (!SWIG_IsOK(res2)) {
33511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33512 }
33513 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 (arg1)->SetEventHandler(arg2);
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 resultobj = SWIG_Py_Void();
33521 return resultobj;
33522 fail:
33523 return NULL;
33524 }
33525
33526
33527 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33528 PyObject *resultobj = 0;
33529 wxWindow *arg1 = (wxWindow *) 0 ;
33530 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33531 void *argp1 = 0 ;
33532 int res1 = 0 ;
33533 void *argp2 = 0 ;
33534 int res2 = 0 ;
33535 PyObject * obj0 = 0 ;
33536 PyObject * obj1 = 0 ;
33537 char * kwnames[] = {
33538 (char *) "self",(char *) "handler", NULL
33539 };
33540
33541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33543 if (!SWIG_IsOK(res1)) {
33544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33545 }
33546 arg1 = reinterpret_cast< wxWindow * >(argp1);
33547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33548 if (!SWIG_IsOK(res2)) {
33549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33550 }
33551 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33552 {
33553 PyThreadState* __tstate = wxPyBeginAllowThreads();
33554 (arg1)->PushEventHandler(arg2);
33555 wxPyEndAllowThreads(__tstate);
33556 if (PyErr_Occurred()) SWIG_fail;
33557 }
33558 resultobj = SWIG_Py_Void();
33559 return resultobj;
33560 fail:
33561 return NULL;
33562 }
33563
33564
33565 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33566 PyObject *resultobj = 0;
33567 wxWindow *arg1 = (wxWindow *) 0 ;
33568 bool arg2 = (bool) false ;
33569 wxEvtHandler *result = 0 ;
33570 void *argp1 = 0 ;
33571 int res1 = 0 ;
33572 bool val2 ;
33573 int ecode2 = 0 ;
33574 PyObject * obj0 = 0 ;
33575 PyObject * obj1 = 0 ;
33576 char * kwnames[] = {
33577 (char *) "self",(char *) "deleteHandler", NULL
33578 };
33579
33580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33582 if (!SWIG_IsOK(res1)) {
33583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33584 }
33585 arg1 = reinterpret_cast< wxWindow * >(argp1);
33586 if (obj1) {
33587 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33588 if (!SWIG_IsOK(ecode2)) {
33589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33590 }
33591 arg2 = static_cast< bool >(val2);
33592 }
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 {
33600 resultobj = wxPyMake_wxObject(result, 0);
33601 }
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33609 PyObject *resultobj = 0;
33610 wxWindow *arg1 = (wxWindow *) 0 ;
33611 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33612 bool result;
33613 void *argp1 = 0 ;
33614 int res1 = 0 ;
33615 void *argp2 = 0 ;
33616 int res2 = 0 ;
33617 PyObject * obj0 = 0 ;
33618 PyObject * obj1 = 0 ;
33619 char * kwnames[] = {
33620 (char *) "self",(char *) "handler", NULL
33621 };
33622
33623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33630 if (!SWIG_IsOK(res2)) {
33631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33632 }
33633 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33634 {
33635 PyThreadState* __tstate = wxPyBeginAllowThreads();
33636 result = (bool)(arg1)->RemoveEventHandler(arg2);
33637 wxPyEndAllowThreads(__tstate);
33638 if (PyErr_Occurred()) SWIG_fail;
33639 }
33640 {
33641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33642 }
33643 return resultobj;
33644 fail:
33645 return NULL;
33646 }
33647
33648
33649 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33650 PyObject *resultobj = 0;
33651 wxWindow *arg1 = (wxWindow *) 0 ;
33652 wxValidator *arg2 = 0 ;
33653 void *argp1 = 0 ;
33654 int res1 = 0 ;
33655 void *argp2 = 0 ;
33656 int res2 = 0 ;
33657 PyObject * obj0 = 0 ;
33658 PyObject * obj1 = 0 ;
33659 char * kwnames[] = {
33660 (char *) "self",(char *) "validator", NULL
33661 };
33662
33663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33665 if (!SWIG_IsOK(res1)) {
33666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33667 }
33668 arg1 = reinterpret_cast< wxWindow * >(argp1);
33669 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33670 if (!SWIG_IsOK(res2)) {
33671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33672 }
33673 if (!argp2) {
33674 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33675 }
33676 arg2 = reinterpret_cast< wxValidator * >(argp2);
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 (arg1)->SetValidator((wxValidator const &)*arg2);
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 resultobj = SWIG_Py_Void();
33684 return resultobj;
33685 fail:
33686 return NULL;
33687 }
33688
33689
33690 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33691 PyObject *resultobj = 0;
33692 wxWindow *arg1 = (wxWindow *) 0 ;
33693 wxValidator *result = 0 ;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 PyObject *swig_obj[1] ;
33697
33698 if (!args) SWIG_fail;
33699 swig_obj[0] = args;
33700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 {
33706 PyThreadState* __tstate = wxPyBeginAllowThreads();
33707 result = (wxValidator *)(arg1)->GetValidator();
33708 wxPyEndAllowThreads(__tstate);
33709 if (PyErr_Occurred()) SWIG_fail;
33710 }
33711 {
33712 resultobj = wxPyMake_wxObject(result, (bool)0);
33713 }
33714 return resultobj;
33715 fail:
33716 return NULL;
33717 }
33718
33719
33720 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33721 PyObject *resultobj = 0;
33722 wxWindow *arg1 = (wxWindow *) 0 ;
33723 bool result;
33724 void *argp1 = 0 ;
33725 int res1 = 0 ;
33726 PyObject *swig_obj[1] ;
33727
33728 if (!args) SWIG_fail;
33729 swig_obj[0] = args;
33730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33731 if (!SWIG_IsOK(res1)) {
33732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33733 }
33734 arg1 = reinterpret_cast< wxWindow * >(argp1);
33735 {
33736 PyThreadState* __tstate = wxPyBeginAllowThreads();
33737 result = (bool)(arg1)->Validate();
33738 wxPyEndAllowThreads(__tstate);
33739 if (PyErr_Occurred()) SWIG_fail;
33740 }
33741 {
33742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33743 }
33744 return resultobj;
33745 fail:
33746 return NULL;
33747 }
33748
33749
33750 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33751 PyObject *resultobj = 0;
33752 wxWindow *arg1 = (wxWindow *) 0 ;
33753 bool result;
33754 void *argp1 = 0 ;
33755 int res1 = 0 ;
33756 PyObject *swig_obj[1] ;
33757
33758 if (!args) SWIG_fail;
33759 swig_obj[0] = args;
33760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33761 if (!SWIG_IsOK(res1)) {
33762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33763 }
33764 arg1 = reinterpret_cast< wxWindow * >(argp1);
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 result = (bool)(arg1)->TransferDataToWindow();
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 {
33772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33773 }
33774 return resultobj;
33775 fail:
33776 return NULL;
33777 }
33778
33779
33780 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33781 PyObject *resultobj = 0;
33782 wxWindow *arg1 = (wxWindow *) 0 ;
33783 bool result;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 PyObject *swig_obj[1] ;
33787
33788 if (!args) SWIG_fail;
33789 swig_obj[0] = args;
33790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33791 if (!SWIG_IsOK(res1)) {
33792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33793 }
33794 arg1 = reinterpret_cast< wxWindow * >(argp1);
33795 {
33796 PyThreadState* __tstate = wxPyBeginAllowThreads();
33797 result = (bool)(arg1)->TransferDataFromWindow();
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 {
33802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33803 }
33804 return resultobj;
33805 fail:
33806 return NULL;
33807 }
33808
33809
33810 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33811 PyObject *resultobj = 0;
33812 wxWindow *arg1 = (wxWindow *) 0 ;
33813 void *argp1 = 0 ;
33814 int res1 = 0 ;
33815 PyObject *swig_obj[1] ;
33816
33817 if (!args) SWIG_fail;
33818 swig_obj[0] = args;
33819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33820 if (!SWIG_IsOK(res1)) {
33821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33822 }
33823 arg1 = reinterpret_cast< wxWindow * >(argp1);
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 (arg1)->InitDialog();
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 resultobj = SWIG_Py_Void();
33831 return resultobj;
33832 fail:
33833 return NULL;
33834 }
33835
33836
33837 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33838 PyObject *resultobj = 0;
33839 wxWindow *arg1 = (wxWindow *) 0 ;
33840 wxAcceleratorTable *arg2 = 0 ;
33841 void *argp1 = 0 ;
33842 int res1 = 0 ;
33843 void *argp2 = 0 ;
33844 int res2 = 0 ;
33845 PyObject * obj0 = 0 ;
33846 PyObject * obj1 = 0 ;
33847 char * kwnames[] = {
33848 (char *) "self",(char *) "accel", NULL
33849 };
33850
33851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33853 if (!SWIG_IsOK(res1)) {
33854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33855 }
33856 arg1 = reinterpret_cast< wxWindow * >(argp1);
33857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33858 if (!SWIG_IsOK(res2)) {
33859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33860 }
33861 if (!argp2) {
33862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33863 }
33864 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33865 {
33866 PyThreadState* __tstate = wxPyBeginAllowThreads();
33867 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33868 wxPyEndAllowThreads(__tstate);
33869 if (PyErr_Occurred()) SWIG_fail;
33870 }
33871 resultobj = SWIG_Py_Void();
33872 return resultobj;
33873 fail:
33874 return NULL;
33875 }
33876
33877
33878 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33879 PyObject *resultobj = 0;
33880 wxWindow *arg1 = (wxWindow *) 0 ;
33881 wxAcceleratorTable *result = 0 ;
33882 void *argp1 = 0 ;
33883 int res1 = 0 ;
33884 PyObject *swig_obj[1] ;
33885
33886 if (!args) SWIG_fail;
33887 swig_obj[0] = args;
33888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33889 if (!SWIG_IsOK(res1)) {
33890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33891 }
33892 arg1 = reinterpret_cast< wxWindow * >(argp1);
33893 {
33894 PyThreadState* __tstate = wxPyBeginAllowThreads();
33895 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33896 wxPyEndAllowThreads(__tstate);
33897 if (PyErr_Occurred()) SWIG_fail;
33898 }
33899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33900 return resultobj;
33901 fail:
33902 return NULL;
33903 }
33904
33905
33906 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33907 PyObject *resultobj = 0;
33908 wxWindow *arg1 = (wxWindow *) 0 ;
33909 int arg2 ;
33910 int arg3 ;
33911 int arg4 ;
33912 bool result;
33913 void *argp1 = 0 ;
33914 int res1 = 0 ;
33915 int val2 ;
33916 int ecode2 = 0 ;
33917 int val3 ;
33918 int ecode3 = 0 ;
33919 int val4 ;
33920 int ecode4 = 0 ;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 PyObject * obj2 = 0 ;
33924 PyObject * obj3 = 0 ;
33925 char * kwnames[] = {
33926 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33927 };
33928
33929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33931 if (!SWIG_IsOK(res1)) {
33932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33933 }
33934 arg1 = reinterpret_cast< wxWindow * >(argp1);
33935 ecode2 = SWIG_AsVal_int(obj1, &val2);
33936 if (!SWIG_IsOK(ecode2)) {
33937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33938 }
33939 arg2 = static_cast< int >(val2);
33940 ecode3 = SWIG_AsVal_int(obj2, &val3);
33941 if (!SWIG_IsOK(ecode3)) {
33942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33943 }
33944 arg3 = static_cast< int >(val3);
33945 ecode4 = SWIG_AsVal_int(obj3, &val4);
33946 if (!SWIG_IsOK(ecode4)) {
33947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33948 }
33949 arg4 = static_cast< int >(val4);
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 {
33957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33958 }
33959 return resultobj;
33960 fail:
33961 return NULL;
33962 }
33963
33964
33965 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33966 PyObject *resultobj = 0;
33967 wxWindow *arg1 = (wxWindow *) 0 ;
33968 int arg2 ;
33969 bool result;
33970 void *argp1 = 0 ;
33971 int res1 = 0 ;
33972 int val2 ;
33973 int ecode2 = 0 ;
33974 PyObject * obj0 = 0 ;
33975 PyObject * obj1 = 0 ;
33976 char * kwnames[] = {
33977 (char *) "self",(char *) "hotkeyId", NULL
33978 };
33979
33980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 ecode2 = SWIG_AsVal_int(obj1, &val2);
33987 if (!SWIG_IsOK(ecode2)) {
33988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33989 }
33990 arg2 = static_cast< int >(val2);
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33994 wxPyEndAllowThreads(__tstate);
33995 if (PyErr_Occurred()) SWIG_fail;
33996 }
33997 {
33998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33999 }
34000 return resultobj;
34001 fail:
34002 return NULL;
34003 }
34004
34005
34006 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34007 PyObject *resultobj = 0;
34008 wxWindow *arg1 = (wxWindow *) 0 ;
34009 wxPoint *arg2 = 0 ;
34010 wxPoint result;
34011 void *argp1 = 0 ;
34012 int res1 = 0 ;
34013 wxPoint temp2 ;
34014 PyObject * obj0 = 0 ;
34015 PyObject * obj1 = 0 ;
34016 char * kwnames[] = {
34017 (char *) "self",(char *) "pt", NULL
34018 };
34019
34020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34022 if (!SWIG_IsOK(res1)) {
34023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34024 }
34025 arg1 = reinterpret_cast< wxWindow * >(argp1);
34026 {
34027 arg2 = &temp2;
34028 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34029 }
34030 {
34031 PyThreadState* __tstate = wxPyBeginAllowThreads();
34032 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34033 wxPyEndAllowThreads(__tstate);
34034 if (PyErr_Occurred()) SWIG_fail;
34035 }
34036 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34037 return resultobj;
34038 fail:
34039 return NULL;
34040 }
34041
34042
34043 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34044 PyObject *resultobj = 0;
34045 wxWindow *arg1 = (wxWindow *) 0 ;
34046 wxSize *arg2 = 0 ;
34047 wxSize result;
34048 void *argp1 = 0 ;
34049 int res1 = 0 ;
34050 wxSize temp2 ;
34051 PyObject * obj0 = 0 ;
34052 PyObject * obj1 = 0 ;
34053 char * kwnames[] = {
34054 (char *) "self",(char *) "sz", NULL
34055 };
34056
34057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34059 if (!SWIG_IsOK(res1)) {
34060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34061 }
34062 arg1 = reinterpret_cast< wxWindow * >(argp1);
34063 {
34064 arg2 = &temp2;
34065 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34066 }
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34081 PyObject *resultobj = 0;
34082 wxWindow *arg1 = (wxWindow *) 0 ;
34083 wxPoint *arg2 = 0 ;
34084 wxPoint result;
34085 void *argp1 = 0 ;
34086 int res1 = 0 ;
34087 wxPoint temp2 ;
34088 PyObject * obj0 = 0 ;
34089 PyObject * obj1 = 0 ;
34090 char * kwnames[] = {
34091 (char *) "self",(char *) "pt", NULL
34092 };
34093
34094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34096 if (!SWIG_IsOK(res1)) {
34097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34098 }
34099 arg1 = reinterpret_cast< wxWindow * >(argp1);
34100 {
34101 arg2 = &temp2;
34102 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34103 }
34104 {
34105 PyThreadState* __tstate = wxPyBeginAllowThreads();
34106 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34107 wxPyEndAllowThreads(__tstate);
34108 if (PyErr_Occurred()) SWIG_fail;
34109 }
34110 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34118 PyObject *resultobj = 0;
34119 wxWindow *arg1 = (wxWindow *) 0 ;
34120 wxSize *arg2 = 0 ;
34121 wxSize result;
34122 void *argp1 = 0 ;
34123 int res1 = 0 ;
34124 wxSize temp2 ;
34125 PyObject * obj0 = 0 ;
34126 PyObject * obj1 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "sz", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 {
34138 arg2 = &temp2;
34139 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34140 }
34141 {
34142 PyThreadState* __tstate = wxPyBeginAllowThreads();
34143 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34144 wxPyEndAllowThreads(__tstate);
34145 if (PyErr_Occurred()) SWIG_fail;
34146 }
34147 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34148 return resultobj;
34149 fail:
34150 return NULL;
34151 }
34152
34153
34154 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34155 PyObject *resultobj = 0;
34156 wxWindow *arg1 = (wxWindow *) 0 ;
34157 wxPoint *arg2 = 0 ;
34158 wxPoint result;
34159 void *argp1 = 0 ;
34160 int res1 = 0 ;
34161 wxPoint temp2 ;
34162 PyObject * obj0 = 0 ;
34163 PyObject * obj1 = 0 ;
34164 char * kwnames[] = {
34165 (char *) "self",(char *) "pt", NULL
34166 };
34167
34168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34170 if (!SWIG_IsOK(res1)) {
34171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34172 }
34173 arg1 = reinterpret_cast< wxWindow * >(argp1);
34174 {
34175 arg2 = &temp2;
34176 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34177 }
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34192 PyObject *resultobj = 0;
34193 wxWindow *arg1 = (wxWindow *) 0 ;
34194 wxSize *arg2 = 0 ;
34195 wxSize result;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 wxSize temp2 ;
34199 PyObject * obj0 = 0 ;
34200 PyObject * obj1 = 0 ;
34201 char * kwnames[] = {
34202 (char *) "self",(char *) "sz", NULL
34203 };
34204
34205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34209 }
34210 arg1 = reinterpret_cast< wxWindow * >(argp1);
34211 {
34212 arg2 = &temp2;
34213 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34214 }
34215 {
34216 PyThreadState* __tstate = wxPyBeginAllowThreads();
34217 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34218 wxPyEndAllowThreads(__tstate);
34219 if (PyErr_Occurred()) SWIG_fail;
34220 }
34221 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34229 PyObject *resultobj = 0;
34230 wxWindow *arg1 = (wxWindow *) 0 ;
34231 int arg2 ;
34232 int arg3 ;
34233 void *argp1 = 0 ;
34234 int res1 = 0 ;
34235 int val2 ;
34236 int ecode2 = 0 ;
34237 int val3 ;
34238 int ecode3 = 0 ;
34239 PyObject * obj0 = 0 ;
34240 PyObject * obj1 = 0 ;
34241 PyObject * obj2 = 0 ;
34242 char * kwnames[] = {
34243 (char *) "self",(char *) "x",(char *) "y", NULL
34244 };
34245
34246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34248 if (!SWIG_IsOK(res1)) {
34249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34250 }
34251 arg1 = reinterpret_cast< wxWindow * >(argp1);
34252 ecode2 = SWIG_AsVal_int(obj1, &val2);
34253 if (!SWIG_IsOK(ecode2)) {
34254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34255 }
34256 arg2 = static_cast< int >(val2);
34257 ecode3 = SWIG_AsVal_int(obj2, &val3);
34258 if (!SWIG_IsOK(ecode3)) {
34259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34260 }
34261 arg3 = static_cast< int >(val3);
34262 {
34263 PyThreadState* __tstate = wxPyBeginAllowThreads();
34264 (arg1)->WarpPointer(arg2,arg3);
34265 wxPyEndAllowThreads(__tstate);
34266 if (PyErr_Occurred()) SWIG_fail;
34267 }
34268 resultobj = SWIG_Py_Void();
34269 return resultobj;
34270 fail:
34271 return NULL;
34272 }
34273
34274
34275 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34276 PyObject *resultobj = 0;
34277 wxWindow *arg1 = (wxWindow *) 0 ;
34278 void *argp1 = 0 ;
34279 int res1 = 0 ;
34280 PyObject *swig_obj[1] ;
34281
34282 if (!args) SWIG_fail;
34283 swig_obj[0] = args;
34284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34285 if (!SWIG_IsOK(res1)) {
34286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34287 }
34288 arg1 = reinterpret_cast< wxWindow * >(argp1);
34289 {
34290 PyThreadState* __tstate = wxPyBeginAllowThreads();
34291 (arg1)->CaptureMouse();
34292 wxPyEndAllowThreads(__tstate);
34293 if (PyErr_Occurred()) SWIG_fail;
34294 }
34295 resultobj = SWIG_Py_Void();
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34303 PyObject *resultobj = 0;
34304 wxWindow *arg1 = (wxWindow *) 0 ;
34305 void *argp1 = 0 ;
34306 int res1 = 0 ;
34307 PyObject *swig_obj[1] ;
34308
34309 if (!args) SWIG_fail;
34310 swig_obj[0] = args;
34311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34312 if (!SWIG_IsOK(res1)) {
34313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34314 }
34315 arg1 = reinterpret_cast< wxWindow * >(argp1);
34316 {
34317 PyThreadState* __tstate = wxPyBeginAllowThreads();
34318 (arg1)->ReleaseMouse();
34319 wxPyEndAllowThreads(__tstate);
34320 if (PyErr_Occurred()) SWIG_fail;
34321 }
34322 resultobj = SWIG_Py_Void();
34323 return resultobj;
34324 fail:
34325 return NULL;
34326 }
34327
34328
34329 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34330 PyObject *resultobj = 0;
34331 wxWindow *result = 0 ;
34332
34333 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34334 {
34335 if (!wxPyCheckForApp()) SWIG_fail;
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = (wxWindow *)wxWindow::GetCapture();
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 {
34342 resultobj = wxPyMake_wxObject(result, 0);
34343 }
34344 return resultobj;
34345 fail:
34346 return NULL;
34347 }
34348
34349
34350 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34351 PyObject *resultobj = 0;
34352 wxWindow *arg1 = (wxWindow *) 0 ;
34353 bool result;
34354 void *argp1 = 0 ;
34355 int res1 = 0 ;
34356 PyObject *swig_obj[1] ;
34357
34358 if (!args) SWIG_fail;
34359 swig_obj[0] = args;
34360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34363 }
34364 arg1 = reinterpret_cast< wxWindow * >(argp1);
34365 {
34366 PyThreadState* __tstate = wxPyBeginAllowThreads();
34367 result = (bool)((wxWindow const *)arg1)->HasCapture();
34368 wxPyEndAllowThreads(__tstate);
34369 if (PyErr_Occurred()) SWIG_fail;
34370 }
34371 {
34372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34373 }
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 bool arg2 = (bool) true ;
34384 wxRect *arg3 = (wxRect *) NULL ;
34385 void *argp1 = 0 ;
34386 int res1 = 0 ;
34387 bool val2 ;
34388 int ecode2 = 0 ;
34389 void *argp3 = 0 ;
34390 int res3 = 0 ;
34391 PyObject * obj0 = 0 ;
34392 PyObject * obj1 = 0 ;
34393 PyObject * obj2 = 0 ;
34394 char * kwnames[] = {
34395 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34396 };
34397
34398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34400 if (!SWIG_IsOK(res1)) {
34401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34402 }
34403 arg1 = reinterpret_cast< wxWindow * >(argp1);
34404 if (obj1) {
34405 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34406 if (!SWIG_IsOK(ecode2)) {
34407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34408 }
34409 arg2 = static_cast< bool >(val2);
34410 }
34411 if (obj2) {
34412 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34413 if (!SWIG_IsOK(res3)) {
34414 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34415 }
34416 arg3 = reinterpret_cast< wxRect * >(argp3);
34417 }
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_Py_Void();
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 wxRect *arg2 = 0 ;
34435 bool arg3 = (bool) true ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 wxRect temp2 ;
34439 bool val3 ;
34440 int ecode3 = 0 ;
34441 PyObject * obj0 = 0 ;
34442 PyObject * obj1 = 0 ;
34443 PyObject * obj2 = 0 ;
34444 char * kwnames[] = {
34445 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34446 };
34447
34448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34450 if (!SWIG_IsOK(res1)) {
34451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34452 }
34453 arg1 = reinterpret_cast< wxWindow * >(argp1);
34454 {
34455 arg2 = &temp2;
34456 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34457 }
34458 if (obj2) {
34459 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34460 if (!SWIG_IsOK(ecode3)) {
34461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34462 }
34463 arg3 = static_cast< bool >(val3);
34464 }
34465 {
34466 PyThreadState* __tstate = wxPyBeginAllowThreads();
34467 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34468 wxPyEndAllowThreads(__tstate);
34469 if (PyErr_Occurred()) SWIG_fail;
34470 }
34471 resultobj = SWIG_Py_Void();
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34479 PyObject *resultobj = 0;
34480 wxWindow *arg1 = (wxWindow *) 0 ;
34481 void *argp1 = 0 ;
34482 int res1 = 0 ;
34483 PyObject *swig_obj[1] ;
34484
34485 if (!args) SWIG_fail;
34486 swig_obj[0] = args;
34487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 (arg1)->Update();
34495 wxPyEndAllowThreads(__tstate);
34496 if (PyErr_Occurred()) SWIG_fail;
34497 }
34498 resultobj = SWIG_Py_Void();
34499 return resultobj;
34500 fail:
34501 return NULL;
34502 }
34503
34504
34505 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34506 PyObject *resultobj = 0;
34507 wxWindow *arg1 = (wxWindow *) 0 ;
34508 void *argp1 = 0 ;
34509 int res1 = 0 ;
34510 PyObject *swig_obj[1] ;
34511
34512 if (!args) SWIG_fail;
34513 swig_obj[0] = args;
34514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34515 if (!SWIG_IsOK(res1)) {
34516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34517 }
34518 arg1 = reinterpret_cast< wxWindow * >(argp1);
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 (arg1)->ClearBackground();
34522 wxPyEndAllowThreads(__tstate);
34523 if (PyErr_Occurred()) SWIG_fail;
34524 }
34525 resultobj = SWIG_Py_Void();
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34533 PyObject *resultobj = 0;
34534 wxWindow *arg1 = (wxWindow *) 0 ;
34535 void *argp1 = 0 ;
34536 int res1 = 0 ;
34537 PyObject *swig_obj[1] ;
34538
34539 if (!args) SWIG_fail;
34540 swig_obj[0] = args;
34541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 {
34547 PyThreadState* __tstate = wxPyBeginAllowThreads();
34548 (arg1)->Freeze();
34549 wxPyEndAllowThreads(__tstate);
34550 if (PyErr_Occurred()) SWIG_fail;
34551 }
34552 resultobj = SWIG_Py_Void();
34553 return resultobj;
34554 fail:
34555 return NULL;
34556 }
34557
34558
34559 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34560 PyObject *resultobj = 0;
34561 wxWindow *arg1 = (wxWindow *) 0 ;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 PyObject *swig_obj[1] ;
34565
34566 if (!args) SWIG_fail;
34567 swig_obj[0] = args;
34568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34569 if (!SWIG_IsOK(res1)) {
34570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34571 }
34572 arg1 = reinterpret_cast< wxWindow * >(argp1);
34573 {
34574 PyThreadState* __tstate = wxPyBeginAllowThreads();
34575 (arg1)->Thaw();
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 resultobj = SWIG_Py_Void();
34580 return resultobj;
34581 fail:
34582 return NULL;
34583 }
34584
34585
34586 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34587 PyObject *resultobj = 0;
34588 wxWindow *arg1 = (wxWindow *) 0 ;
34589 wxDC *arg2 = 0 ;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 void *argp2 = 0 ;
34593 int res2 = 0 ;
34594 PyObject * obj0 = 0 ;
34595 PyObject * obj1 = 0 ;
34596 char * kwnames[] = {
34597 (char *) "self",(char *) "dc", NULL
34598 };
34599
34600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34602 if (!SWIG_IsOK(res1)) {
34603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34604 }
34605 arg1 = reinterpret_cast< wxWindow * >(argp1);
34606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34607 if (!SWIG_IsOK(res2)) {
34608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34609 }
34610 if (!argp2) {
34611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34612 }
34613 arg2 = reinterpret_cast< wxDC * >(argp2);
34614 {
34615 PyThreadState* __tstate = wxPyBeginAllowThreads();
34616 (arg1)->PrepareDC(*arg2);
34617 wxPyEndAllowThreads(__tstate);
34618 if (PyErr_Occurred()) SWIG_fail;
34619 }
34620 resultobj = SWIG_Py_Void();
34621 return resultobj;
34622 fail:
34623 return NULL;
34624 }
34625
34626
34627 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34628 PyObject *resultobj = 0;
34629 wxWindow *arg1 = (wxWindow *) 0 ;
34630 wxRegion *result = 0 ;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 PyObject *swig_obj[1] ;
34634
34635 if (!args) SWIG_fail;
34636 swig_obj[0] = args;
34637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34638 if (!SWIG_IsOK(res1)) {
34639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34640 }
34641 arg1 = reinterpret_cast< wxWindow * >(argp1);
34642 {
34643 PyThreadState* __tstate = wxPyBeginAllowThreads();
34644 {
34645 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34646 result = (wxRegion *) &_result_ref;
34647 }
34648 wxPyEndAllowThreads(__tstate);
34649 if (PyErr_Occurred()) SWIG_fail;
34650 }
34651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34652 return resultobj;
34653 fail:
34654 return NULL;
34655 }
34656
34657
34658 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34659 PyObject *resultobj = 0;
34660 wxWindow *arg1 = (wxWindow *) 0 ;
34661 wxRect result;
34662 void *argp1 = 0 ;
34663 int res1 = 0 ;
34664 PyObject *swig_obj[1] ;
34665
34666 if (!args) SWIG_fail;
34667 swig_obj[0] = args;
34668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34669 if (!SWIG_IsOK(res1)) {
34670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34671 }
34672 arg1 = reinterpret_cast< wxWindow * >(argp1);
34673 {
34674 PyThreadState* __tstate = wxPyBeginAllowThreads();
34675 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34680 return resultobj;
34681 fail:
34682 return NULL;
34683 }
34684
34685
34686 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34687 PyObject *resultobj = 0;
34688 wxWindow *arg1 = (wxWindow *) 0 ;
34689 int arg2 ;
34690 int arg3 ;
34691 int arg4 = (int) 1 ;
34692 int arg5 = (int) 1 ;
34693 bool result;
34694 void *argp1 = 0 ;
34695 int res1 = 0 ;
34696 int val2 ;
34697 int ecode2 = 0 ;
34698 int val3 ;
34699 int ecode3 = 0 ;
34700 int val4 ;
34701 int ecode4 = 0 ;
34702 int val5 ;
34703 int ecode5 = 0 ;
34704 PyObject * obj0 = 0 ;
34705 PyObject * obj1 = 0 ;
34706 PyObject * obj2 = 0 ;
34707 PyObject * obj3 = 0 ;
34708 PyObject * obj4 = 0 ;
34709 char * kwnames[] = {
34710 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34711 };
34712
34713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34715 if (!SWIG_IsOK(res1)) {
34716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34717 }
34718 arg1 = reinterpret_cast< wxWindow * >(argp1);
34719 ecode2 = SWIG_AsVal_int(obj1, &val2);
34720 if (!SWIG_IsOK(ecode2)) {
34721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34722 }
34723 arg2 = static_cast< int >(val2);
34724 ecode3 = SWIG_AsVal_int(obj2, &val3);
34725 if (!SWIG_IsOK(ecode3)) {
34726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34727 }
34728 arg3 = static_cast< int >(val3);
34729 if (obj3) {
34730 ecode4 = SWIG_AsVal_int(obj3, &val4);
34731 if (!SWIG_IsOK(ecode4)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34733 }
34734 arg4 = static_cast< int >(val4);
34735 }
34736 if (obj4) {
34737 ecode5 = SWIG_AsVal_int(obj4, &val5);
34738 if (!SWIG_IsOK(ecode5)) {
34739 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34740 }
34741 arg5 = static_cast< int >(val5);
34742 }
34743 {
34744 PyThreadState* __tstate = wxPyBeginAllowThreads();
34745 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34746 wxPyEndAllowThreads(__tstate);
34747 if (PyErr_Occurred()) SWIG_fail;
34748 }
34749 {
34750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34751 }
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 wxPoint *arg2 = 0 ;
34762 bool result;
34763 void *argp1 = 0 ;
34764 int res1 = 0 ;
34765 wxPoint temp2 ;
34766 PyObject * obj0 = 0 ;
34767 PyObject * obj1 = 0 ;
34768 char * kwnames[] = {
34769 (char *) "self",(char *) "pt", NULL
34770 };
34771
34772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34774 if (!SWIG_IsOK(res1)) {
34775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34776 }
34777 arg1 = reinterpret_cast< wxWindow * >(argp1);
34778 {
34779 arg2 = &temp2;
34780 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34781 }
34782 {
34783 PyThreadState* __tstate = wxPyBeginAllowThreads();
34784 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 {
34789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34790 }
34791 return resultobj;
34792 fail:
34793 return NULL;
34794 }
34795
34796
34797 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34798 PyObject *resultobj = 0;
34799 wxWindow *arg1 = (wxWindow *) 0 ;
34800 wxRect *arg2 = 0 ;
34801 bool result;
34802 void *argp1 = 0 ;
34803 int res1 = 0 ;
34804 wxRect temp2 ;
34805 PyObject * obj0 = 0 ;
34806 PyObject * obj1 = 0 ;
34807 char * kwnames[] = {
34808 (char *) "self",(char *) "rect", NULL
34809 };
34810
34811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34813 if (!SWIG_IsOK(res1)) {
34814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34815 }
34816 arg1 = reinterpret_cast< wxWindow * >(argp1);
34817 {
34818 arg2 = &temp2;
34819 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34820 }
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 {
34828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34829 }
34830 return resultobj;
34831 fail:
34832 return NULL;
34833 }
34834
34835
34836 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxWindow *arg1 = (wxWindow *) 0 ;
34839 SwigValueWrapper<wxVisualAttributes > result;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 PyObject *swig_obj[1] ;
34843
34844 if (!args) SWIG_fail;
34845 swig_obj[0] = args;
34846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34849 }
34850 arg1 = reinterpret_cast< wxWindow * >(argp1);
34851 {
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34858 return resultobj;
34859 fail:
34860 return NULL;
34861 }
34862
34863
34864 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34865 PyObject *resultobj = 0;
34866 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34867 SwigValueWrapper<wxVisualAttributes > result;
34868 int val1 ;
34869 int ecode1 = 0 ;
34870 PyObject * obj0 = 0 ;
34871 char * kwnames[] = {
34872 (char *) "variant", NULL
34873 };
34874
34875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34876 if (obj0) {
34877 ecode1 = SWIG_AsVal_int(obj0, &val1);
34878 if (!SWIG_IsOK(ecode1)) {
34879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34880 }
34881 arg1 = static_cast< wxWindowVariant >(val1);
34882 }
34883 {
34884 if (!wxPyCheckForApp()) SWIG_fail;
34885 PyThreadState* __tstate = wxPyBeginAllowThreads();
34886 result = wxWindow::GetClassDefaultAttributes(arg1);
34887 wxPyEndAllowThreads(__tstate);
34888 if (PyErr_Occurred()) SWIG_fail;
34889 }
34890 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34891 return resultobj;
34892 fail:
34893 return NULL;
34894 }
34895
34896
34897 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34898 PyObject *resultobj = 0;
34899 wxWindow *arg1 = (wxWindow *) 0 ;
34900 wxColour *arg2 = 0 ;
34901 bool result;
34902 void *argp1 = 0 ;
34903 int res1 = 0 ;
34904 wxColour temp2 ;
34905 PyObject * obj0 = 0 ;
34906 PyObject * obj1 = 0 ;
34907 char * kwnames[] = {
34908 (char *) "self",(char *) "colour", NULL
34909 };
34910
34911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34913 if (!SWIG_IsOK(res1)) {
34914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34915 }
34916 arg1 = reinterpret_cast< wxWindow * >(argp1);
34917 {
34918 arg2 = &temp2;
34919 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34920 }
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 {
34928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34929 }
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = 0;
34938 wxWindow *arg1 = (wxWindow *) 0 ;
34939 wxColour *arg2 = 0 ;
34940 void *argp1 = 0 ;
34941 int res1 = 0 ;
34942 wxColour temp2 ;
34943 PyObject * obj0 = 0 ;
34944 PyObject * obj1 = 0 ;
34945 char * kwnames[] = {
34946 (char *) "self",(char *) "colour", NULL
34947 };
34948
34949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34951 if (!SWIG_IsOK(res1)) {
34952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34953 }
34954 arg1 = reinterpret_cast< wxWindow * >(argp1);
34955 {
34956 arg2 = &temp2;
34957 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34958 }
34959 {
34960 PyThreadState* __tstate = wxPyBeginAllowThreads();
34961 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34962 wxPyEndAllowThreads(__tstate);
34963 if (PyErr_Occurred()) SWIG_fail;
34964 }
34965 resultobj = SWIG_Py_Void();
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34973 PyObject *resultobj = 0;
34974 wxWindow *arg1 = (wxWindow *) 0 ;
34975 wxColour *arg2 = 0 ;
34976 bool result;
34977 void *argp1 = 0 ;
34978 int res1 = 0 ;
34979 wxColour temp2 ;
34980 PyObject * obj0 = 0 ;
34981 PyObject * obj1 = 0 ;
34982 char * kwnames[] = {
34983 (char *) "self",(char *) "colour", NULL
34984 };
34985
34986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34988 if (!SWIG_IsOK(res1)) {
34989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34990 }
34991 arg1 = reinterpret_cast< wxWindow * >(argp1);
34992 {
34993 arg2 = &temp2;
34994 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34995 }
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34999 wxPyEndAllowThreads(__tstate);
35000 if (PyErr_Occurred()) SWIG_fail;
35001 }
35002 {
35003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35004 }
35005 return resultobj;
35006 fail:
35007 return NULL;
35008 }
35009
35010
35011 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35012 PyObject *resultobj = 0;
35013 wxWindow *arg1 = (wxWindow *) 0 ;
35014 wxColour *arg2 = 0 ;
35015 void *argp1 = 0 ;
35016 int res1 = 0 ;
35017 wxColour temp2 ;
35018 PyObject * obj0 = 0 ;
35019 PyObject * obj1 = 0 ;
35020 char * kwnames[] = {
35021 (char *) "self",(char *) "colour", NULL
35022 };
35023
35024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35026 if (!SWIG_IsOK(res1)) {
35027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35028 }
35029 arg1 = reinterpret_cast< wxWindow * >(argp1);
35030 {
35031 arg2 = &temp2;
35032 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35033 }
35034 {
35035 PyThreadState* __tstate = wxPyBeginAllowThreads();
35036 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 resultobj = SWIG_Py_Void();
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 wxColour result;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 PyObject *swig_obj[1] ;
35054
35055 if (!args) SWIG_fail;
35056 swig_obj[0] = args;
35057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35058 if (!SWIG_IsOK(res1)) {
35059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35060 }
35061 arg1 = reinterpret_cast< wxWindow * >(argp1);
35062 {
35063 PyThreadState* __tstate = wxPyBeginAllowThreads();
35064 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35065 wxPyEndAllowThreads(__tstate);
35066 if (PyErr_Occurred()) SWIG_fail;
35067 }
35068 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35069 return resultobj;
35070 fail:
35071 return NULL;
35072 }
35073
35074
35075 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35076 PyObject *resultobj = 0;
35077 wxWindow *arg1 = (wxWindow *) 0 ;
35078 wxColour result;
35079 void *argp1 = 0 ;
35080 int res1 = 0 ;
35081 PyObject *swig_obj[1] ;
35082
35083 if (!args) SWIG_fail;
35084 swig_obj[0] = args;
35085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35086 if (!SWIG_IsOK(res1)) {
35087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35088 }
35089 arg1 = reinterpret_cast< wxWindow * >(argp1);
35090 {
35091 PyThreadState* __tstate = wxPyBeginAllowThreads();
35092 result = ((wxWindow const *)arg1)->GetForegroundColour();
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35097 return resultobj;
35098 fail:
35099 return NULL;
35100 }
35101
35102
35103 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35104 PyObject *resultobj = 0;
35105 wxWindow *arg1 = (wxWindow *) 0 ;
35106 bool result;
35107 void *argp1 = 0 ;
35108 int res1 = 0 ;
35109 PyObject *swig_obj[1] ;
35110
35111 if (!args) SWIG_fail;
35112 swig_obj[0] = args;
35113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35116 }
35117 arg1 = reinterpret_cast< wxWindow * >(argp1);
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 {
35125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35126 }
35127 return resultobj;
35128 fail:
35129 return NULL;
35130 }
35131
35132
35133 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35134 PyObject *resultobj = 0;
35135 wxWindow *arg1 = (wxWindow *) 0 ;
35136 bool result;
35137 void *argp1 = 0 ;
35138 int res1 = 0 ;
35139 PyObject *swig_obj[1] ;
35140
35141 if (!args) SWIG_fail;
35142 swig_obj[0] = args;
35143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35144 if (!SWIG_IsOK(res1)) {
35145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35146 }
35147 arg1 = reinterpret_cast< wxWindow * >(argp1);
35148 {
35149 PyThreadState* __tstate = wxPyBeginAllowThreads();
35150 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35151 wxPyEndAllowThreads(__tstate);
35152 if (PyErr_Occurred()) SWIG_fail;
35153 }
35154 {
35155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35156 }
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 wxBackgroundStyle arg2 ;
35167 bool result;
35168 void *argp1 = 0 ;
35169 int res1 = 0 ;
35170 int val2 ;
35171 int ecode2 = 0 ;
35172 PyObject * obj0 = 0 ;
35173 PyObject * obj1 = 0 ;
35174 char * kwnames[] = {
35175 (char *) "self",(char *) "style", NULL
35176 };
35177
35178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35180 if (!SWIG_IsOK(res1)) {
35181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35182 }
35183 arg1 = reinterpret_cast< wxWindow * >(argp1);
35184 ecode2 = SWIG_AsVal_int(obj1, &val2);
35185 if (!SWIG_IsOK(ecode2)) {
35186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35187 }
35188 arg2 = static_cast< wxBackgroundStyle >(val2);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 {
35196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35197 }
35198 return resultobj;
35199 fail:
35200 return NULL;
35201 }
35202
35203
35204 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35205 PyObject *resultobj = 0;
35206 wxWindow *arg1 = (wxWindow *) 0 ;
35207 wxBackgroundStyle result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 PyObject *swig_obj[1] ;
35211
35212 if (!args) SWIG_fail;
35213 swig_obj[0] = args;
35214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35215 if (!SWIG_IsOK(res1)) {
35216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35217 }
35218 arg1 = reinterpret_cast< wxWindow * >(argp1);
35219 {
35220 PyThreadState* __tstate = wxPyBeginAllowThreads();
35221 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35222 wxPyEndAllowThreads(__tstate);
35223 if (PyErr_Occurred()) SWIG_fail;
35224 }
35225 resultobj = SWIG_From_int(static_cast< int >(result));
35226 return resultobj;
35227 fail:
35228 return NULL;
35229 }
35230
35231
35232 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35233 PyObject *resultobj = 0;
35234 wxWindow *arg1 = (wxWindow *) 0 ;
35235 bool result;
35236 void *argp1 = 0 ;
35237 int res1 = 0 ;
35238 PyObject *swig_obj[1] ;
35239
35240 if (!args) SWIG_fail;
35241 swig_obj[0] = args;
35242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35243 if (!SWIG_IsOK(res1)) {
35244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35245 }
35246 arg1 = reinterpret_cast< wxWindow * >(argp1);
35247 {
35248 PyThreadState* __tstate = wxPyBeginAllowThreads();
35249 result = (bool)(arg1)->HasTransparentBackground();
35250 wxPyEndAllowThreads(__tstate);
35251 if (PyErr_Occurred()) SWIG_fail;
35252 }
35253 {
35254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35255 }
35256 return resultobj;
35257 fail:
35258 return NULL;
35259 }
35260
35261
35262 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35263 PyObject *resultobj = 0;
35264 wxWindow *arg1 = (wxWindow *) 0 ;
35265 wxCursor *arg2 = 0 ;
35266 bool result;
35267 void *argp1 = 0 ;
35268 int res1 = 0 ;
35269 void *argp2 = 0 ;
35270 int res2 = 0 ;
35271 PyObject * obj0 = 0 ;
35272 PyObject * obj1 = 0 ;
35273 char * kwnames[] = {
35274 (char *) "self",(char *) "cursor", NULL
35275 };
35276
35277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35279 if (!SWIG_IsOK(res1)) {
35280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35281 }
35282 arg1 = reinterpret_cast< wxWindow * >(argp1);
35283 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35284 if (!SWIG_IsOK(res2)) {
35285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35286 }
35287 if (!argp2) {
35288 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35289 }
35290 arg2 = reinterpret_cast< wxCursor * >(argp2);
35291 {
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 {
35298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35299 }
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35307 PyObject *resultobj = 0;
35308 wxWindow *arg1 = (wxWindow *) 0 ;
35309 wxCursor result;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 PyObject *swig_obj[1] ;
35313
35314 if (!args) SWIG_fail;
35315 swig_obj[0] = args;
35316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35317 if (!SWIG_IsOK(res1)) {
35318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35319 }
35320 arg1 = reinterpret_cast< wxWindow * >(argp1);
35321 {
35322 PyThreadState* __tstate = wxPyBeginAllowThreads();
35323 result = (arg1)->GetCursor();
35324 wxPyEndAllowThreads(__tstate);
35325 if (PyErr_Occurred()) SWIG_fail;
35326 }
35327 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj = 0;
35336 wxWindow *arg1 = (wxWindow *) 0 ;
35337 wxFont *arg2 = 0 ;
35338 bool result;
35339 void *argp1 = 0 ;
35340 int res1 = 0 ;
35341 void *argp2 = 0 ;
35342 int res2 = 0 ;
35343 PyObject * obj0 = 0 ;
35344 PyObject * obj1 = 0 ;
35345 char * kwnames[] = {
35346 (char *) "self",(char *) "font", NULL
35347 };
35348
35349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35356 if (!SWIG_IsOK(res2)) {
35357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35358 }
35359 if (!argp2) {
35360 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35361 }
35362 arg2 = reinterpret_cast< wxFont * >(argp2);
35363 {
35364 PyThreadState* __tstate = wxPyBeginAllowThreads();
35365 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35366 wxPyEndAllowThreads(__tstate);
35367 if (PyErr_Occurred()) SWIG_fail;
35368 }
35369 {
35370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35371 }
35372 return resultobj;
35373 fail:
35374 return NULL;
35375 }
35376
35377
35378 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35379 PyObject *resultobj = 0;
35380 wxWindow *arg1 = (wxWindow *) 0 ;
35381 wxFont *arg2 = 0 ;
35382 void *argp1 = 0 ;
35383 int res1 = 0 ;
35384 void *argp2 = 0 ;
35385 int res2 = 0 ;
35386 PyObject * obj0 = 0 ;
35387 PyObject * obj1 = 0 ;
35388 char * kwnames[] = {
35389 (char *) "self",(char *) "font", NULL
35390 };
35391
35392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35396 }
35397 arg1 = reinterpret_cast< wxWindow * >(argp1);
35398 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35399 if (!SWIG_IsOK(res2)) {
35400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35401 }
35402 if (!argp2) {
35403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35404 }
35405 arg2 = reinterpret_cast< wxFont * >(argp2);
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 (arg1)->SetOwnFont((wxFont const &)*arg2);
35409 wxPyEndAllowThreads(__tstate);
35410 if (PyErr_Occurred()) SWIG_fail;
35411 }
35412 resultobj = SWIG_Py_Void();
35413 return resultobj;
35414 fail:
35415 return NULL;
35416 }
35417
35418
35419 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35420 PyObject *resultobj = 0;
35421 wxWindow *arg1 = (wxWindow *) 0 ;
35422 wxFont result;
35423 void *argp1 = 0 ;
35424 int res1 = 0 ;
35425 PyObject *swig_obj[1] ;
35426
35427 if (!args) SWIG_fail;
35428 swig_obj[0] = args;
35429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35430 if (!SWIG_IsOK(res1)) {
35431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35432 }
35433 arg1 = reinterpret_cast< wxWindow * >(argp1);
35434 {
35435 PyThreadState* __tstate = wxPyBeginAllowThreads();
35436 result = (arg1)->GetFont();
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35441 return resultobj;
35442 fail:
35443 return NULL;
35444 }
35445
35446
35447 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35448 PyObject *resultobj = 0;
35449 wxWindow *arg1 = (wxWindow *) 0 ;
35450 wxCaret *arg2 = (wxCaret *) 0 ;
35451 void *argp1 = 0 ;
35452 int res1 = 0 ;
35453 int res2 = 0 ;
35454 PyObject * obj0 = 0 ;
35455 PyObject * obj1 = 0 ;
35456 char * kwnames[] = {
35457 (char *) "self",(char *) "caret", NULL
35458 };
35459
35460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35462 if (!SWIG_IsOK(res1)) {
35463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35464 }
35465 arg1 = reinterpret_cast< wxWindow * >(argp1);
35466 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35467 if (!SWIG_IsOK(res2)) {
35468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35469 }
35470 {
35471 PyThreadState* __tstate = wxPyBeginAllowThreads();
35472 (arg1)->SetCaret(arg2);
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 resultobj = SWIG_Py_Void();
35477 return resultobj;
35478 fail:
35479 return NULL;
35480 }
35481
35482
35483 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35484 PyObject *resultobj = 0;
35485 wxWindow *arg1 = (wxWindow *) 0 ;
35486 wxCaret *result = 0 ;
35487 void *argp1 = 0 ;
35488 int res1 = 0 ;
35489 PyObject *swig_obj[1] ;
35490
35491 if (!args) SWIG_fail;
35492 swig_obj[0] = args;
35493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35494 if (!SWIG_IsOK(res1)) {
35495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35496 }
35497 arg1 = reinterpret_cast< wxWindow * >(argp1);
35498 {
35499 PyThreadState* __tstate = wxPyBeginAllowThreads();
35500 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35505 return resultobj;
35506 fail:
35507 return NULL;
35508 }
35509
35510
35511 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35512 PyObject *resultobj = 0;
35513 wxWindow *arg1 = (wxWindow *) 0 ;
35514 int result;
35515 void *argp1 = 0 ;
35516 int res1 = 0 ;
35517 PyObject *swig_obj[1] ;
35518
35519 if (!args) SWIG_fail;
35520 swig_obj[0] = args;
35521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35522 if (!SWIG_IsOK(res1)) {
35523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35524 }
35525 arg1 = reinterpret_cast< wxWindow * >(argp1);
35526 {
35527 PyThreadState* __tstate = wxPyBeginAllowThreads();
35528 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35529 wxPyEndAllowThreads(__tstate);
35530 if (PyErr_Occurred()) SWIG_fail;
35531 }
35532 resultobj = SWIG_From_int(static_cast< int >(result));
35533 return resultobj;
35534 fail:
35535 return NULL;
35536 }
35537
35538
35539 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35540 PyObject *resultobj = 0;
35541 wxWindow *arg1 = (wxWindow *) 0 ;
35542 int result;
35543 void *argp1 = 0 ;
35544 int res1 = 0 ;
35545 PyObject *swig_obj[1] ;
35546
35547 if (!args) SWIG_fail;
35548 swig_obj[0] = args;
35549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35550 if (!SWIG_IsOK(res1)) {
35551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35552 }
35553 arg1 = reinterpret_cast< wxWindow * >(argp1);
35554 {
35555 PyThreadState* __tstate = wxPyBeginAllowThreads();
35556 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35557 wxPyEndAllowThreads(__tstate);
35558 if (PyErr_Occurred()) SWIG_fail;
35559 }
35560 resultobj = SWIG_From_int(static_cast< int >(result));
35561 return resultobj;
35562 fail:
35563 return NULL;
35564 }
35565
35566
35567 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35568 PyObject *resultobj = 0;
35569 wxWindow *arg1 = (wxWindow *) 0 ;
35570 wxString *arg2 = 0 ;
35571 int *arg3 = (int *) 0 ;
35572 int *arg4 = (int *) 0 ;
35573 void *argp1 = 0 ;
35574 int res1 = 0 ;
35575 bool temp2 = false ;
35576 int temp3 ;
35577 int res3 = SWIG_TMPOBJ ;
35578 int temp4 ;
35579 int res4 = SWIG_TMPOBJ ;
35580 PyObject * obj0 = 0 ;
35581 PyObject * obj1 = 0 ;
35582 char * kwnames[] = {
35583 (char *) "self",(char *) "string", NULL
35584 };
35585
35586 arg3 = &temp3;
35587 arg4 = &temp4;
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 {
35595 arg2 = wxString_in_helper(obj1);
35596 if (arg2 == NULL) SWIG_fail;
35597 temp2 = true;
35598 }
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_Py_Void();
35606 if (SWIG_IsTmpObj(res3)) {
35607 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35608 } else {
35609 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35610 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35611 }
35612 if (SWIG_IsTmpObj(res4)) {
35613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35614 } else {
35615 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35617 }
35618 {
35619 if (temp2)
35620 delete arg2;
35621 }
35622 return resultobj;
35623 fail:
35624 {
35625 if (temp2)
35626 delete arg2;
35627 }
35628 return NULL;
35629 }
35630
35631
35632 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35633 PyObject *resultobj = 0;
35634 wxWindow *arg1 = (wxWindow *) 0 ;
35635 wxString *arg2 = 0 ;
35636 int *arg3 = (int *) 0 ;
35637 int *arg4 = (int *) 0 ;
35638 int *arg5 = (int *) 0 ;
35639 int *arg6 = (int *) 0 ;
35640 wxFont *arg7 = (wxFont *) NULL ;
35641 void *argp1 = 0 ;
35642 int res1 = 0 ;
35643 bool temp2 = false ;
35644 int temp3 ;
35645 int res3 = SWIG_TMPOBJ ;
35646 int temp4 ;
35647 int res4 = SWIG_TMPOBJ ;
35648 int temp5 ;
35649 int res5 = SWIG_TMPOBJ ;
35650 int temp6 ;
35651 int res6 = SWIG_TMPOBJ ;
35652 void *argp7 = 0 ;
35653 int res7 = 0 ;
35654 PyObject * obj0 = 0 ;
35655 PyObject * obj1 = 0 ;
35656 PyObject * obj2 = 0 ;
35657 char * kwnames[] = {
35658 (char *) "self",(char *) "string",(char *) "font", NULL
35659 };
35660
35661 arg3 = &temp3;
35662 arg4 = &temp4;
35663 arg5 = &temp5;
35664 arg6 = &temp6;
35665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35667 if (!SWIG_IsOK(res1)) {
35668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35669 }
35670 arg1 = reinterpret_cast< wxWindow * >(argp1);
35671 {
35672 arg2 = wxString_in_helper(obj1);
35673 if (arg2 == NULL) SWIG_fail;
35674 temp2 = true;
35675 }
35676 if (obj2) {
35677 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35678 if (!SWIG_IsOK(res7)) {
35679 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35680 }
35681 arg7 = reinterpret_cast< wxFont * >(argp7);
35682 }
35683 {
35684 PyThreadState* __tstate = wxPyBeginAllowThreads();
35685 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35686 wxPyEndAllowThreads(__tstate);
35687 if (PyErr_Occurred()) SWIG_fail;
35688 }
35689 resultobj = SWIG_Py_Void();
35690 if (SWIG_IsTmpObj(res3)) {
35691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35692 } else {
35693 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35695 }
35696 if (SWIG_IsTmpObj(res4)) {
35697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35698 } else {
35699 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35701 }
35702 if (SWIG_IsTmpObj(res5)) {
35703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35704 } else {
35705 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35707 }
35708 if (SWIG_IsTmpObj(res6)) {
35709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35710 } else {
35711 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35713 }
35714 {
35715 if (temp2)
35716 delete arg2;
35717 }
35718 return resultobj;
35719 fail:
35720 {
35721 if (temp2)
35722 delete arg2;
35723 }
35724 return NULL;
35725 }
35726
35727
35728 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35729 PyObject *resultobj = 0;
35730 wxWindow *arg1 = (wxWindow *) 0 ;
35731 int *arg2 = (int *) 0 ;
35732 int *arg3 = (int *) 0 ;
35733 void *argp1 = 0 ;
35734 int res1 = 0 ;
35735 int temp2 ;
35736 int res2 = 0 ;
35737 int temp3 ;
35738 int res3 = 0 ;
35739 PyObject * obj0 = 0 ;
35740 PyObject * obj1 = 0 ;
35741 PyObject * obj2 = 0 ;
35742 char * kwnames[] = {
35743 (char *) "self",(char *) "x",(char *) "y", NULL
35744 };
35745
35746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35748 if (!SWIG_IsOK(res1)) {
35749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35750 }
35751 arg1 = reinterpret_cast< wxWindow * >(argp1);
35752 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35753 int val;
35754 int ecode = SWIG_AsVal_int(obj1, &val);
35755 if (!SWIG_IsOK(ecode)) {
35756 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35757 }
35758 temp2 = static_cast< int >(val);
35759 arg2 = &temp2;
35760 res2 = SWIG_AddTmpMask(ecode);
35761 }
35762 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35763 int val;
35764 int ecode = SWIG_AsVal_int(obj2, &val);
35765 if (!SWIG_IsOK(ecode)) {
35766 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35767 }
35768 temp3 = static_cast< int >(val);
35769 arg3 = &temp3;
35770 res3 = SWIG_AddTmpMask(ecode);
35771 }
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 resultobj = SWIG_Py_Void();
35779 if (SWIG_IsTmpObj(res2)) {
35780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35781 } else {
35782 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35784 }
35785 if (SWIG_IsTmpObj(res3)) {
35786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35787 } else {
35788 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35790 }
35791 return resultobj;
35792 fail:
35793 return NULL;
35794 }
35795
35796
35797 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35798 PyObject *resultobj = 0;
35799 wxWindow *arg1 = (wxWindow *) 0 ;
35800 int *arg2 = (int *) 0 ;
35801 int *arg3 = (int *) 0 ;
35802 void *argp1 = 0 ;
35803 int res1 = 0 ;
35804 int temp2 ;
35805 int res2 = 0 ;
35806 int temp3 ;
35807 int res3 = 0 ;
35808 PyObject * obj0 = 0 ;
35809 PyObject * obj1 = 0 ;
35810 PyObject * obj2 = 0 ;
35811 char * kwnames[] = {
35812 (char *) "self",(char *) "x",(char *) "y", NULL
35813 };
35814
35815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35817 if (!SWIG_IsOK(res1)) {
35818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35819 }
35820 arg1 = reinterpret_cast< wxWindow * >(argp1);
35821 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35822 int val;
35823 int ecode = SWIG_AsVal_int(obj1, &val);
35824 if (!SWIG_IsOK(ecode)) {
35825 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35826 }
35827 temp2 = static_cast< int >(val);
35828 arg2 = &temp2;
35829 res2 = SWIG_AddTmpMask(ecode);
35830 }
35831 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35832 int val;
35833 int ecode = SWIG_AsVal_int(obj2, &val);
35834 if (!SWIG_IsOK(ecode)) {
35835 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35836 }
35837 temp3 = static_cast< int >(val);
35838 arg3 = &temp3;
35839 res3 = SWIG_AddTmpMask(ecode);
35840 }
35841 {
35842 PyThreadState* __tstate = wxPyBeginAllowThreads();
35843 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35844 wxPyEndAllowThreads(__tstate);
35845 if (PyErr_Occurred()) SWIG_fail;
35846 }
35847 resultobj = SWIG_Py_Void();
35848 if (SWIG_IsTmpObj(res2)) {
35849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35850 } else {
35851 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35853 }
35854 if (SWIG_IsTmpObj(res3)) {
35855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35856 } else {
35857 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35859 }
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj = 0;
35868 wxWindow *arg1 = (wxWindow *) 0 ;
35869 wxPoint *arg2 = 0 ;
35870 wxPoint result;
35871 void *argp1 = 0 ;
35872 int res1 = 0 ;
35873 wxPoint temp2 ;
35874 PyObject * obj0 = 0 ;
35875 PyObject * obj1 = 0 ;
35876 char * kwnames[] = {
35877 (char *) "self",(char *) "pt", NULL
35878 };
35879
35880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35882 if (!SWIG_IsOK(res1)) {
35883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35884 }
35885 arg1 = reinterpret_cast< wxWindow * >(argp1);
35886 {
35887 arg2 = &temp2;
35888 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35889 }
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35893 wxPyEndAllowThreads(__tstate);
35894 if (PyErr_Occurred()) SWIG_fail;
35895 }
35896 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxWindow *arg1 = (wxWindow *) 0 ;
35906 wxPoint *arg2 = 0 ;
35907 wxPoint result;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 wxPoint temp2 ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 char * kwnames[] = {
35914 (char *) "self",(char *) "pt", NULL
35915 };
35916
35917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35919 if (!SWIG_IsOK(res1)) {
35920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35921 }
35922 arg1 = reinterpret_cast< wxWindow * >(argp1);
35923 {
35924 arg2 = &temp2;
35925 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35926 }
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35934 return resultobj;
35935 fail:
35936 return NULL;
35937 }
35938
35939
35940 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35941 PyObject *resultobj = 0;
35942 wxWindow *arg1 = (wxWindow *) 0 ;
35943 int arg2 ;
35944 int arg3 ;
35945 wxHitTest result;
35946 void *argp1 = 0 ;
35947 int res1 = 0 ;
35948 int val2 ;
35949 int ecode2 = 0 ;
35950 int val3 ;
35951 int ecode3 = 0 ;
35952 PyObject * obj0 = 0 ;
35953 PyObject * obj1 = 0 ;
35954 PyObject * obj2 = 0 ;
35955 char * kwnames[] = {
35956 (char *) "self",(char *) "x",(char *) "y", NULL
35957 };
35958
35959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35961 if (!SWIG_IsOK(res1)) {
35962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35963 }
35964 arg1 = reinterpret_cast< wxWindow * >(argp1);
35965 ecode2 = SWIG_AsVal_int(obj1, &val2);
35966 if (!SWIG_IsOK(ecode2)) {
35967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35968 }
35969 arg2 = static_cast< int >(val2);
35970 ecode3 = SWIG_AsVal_int(obj2, &val3);
35971 if (!SWIG_IsOK(ecode3)) {
35972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35973 }
35974 arg3 = static_cast< int >(val3);
35975 {
35976 PyThreadState* __tstate = wxPyBeginAllowThreads();
35977 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35978 wxPyEndAllowThreads(__tstate);
35979 if (PyErr_Occurred()) SWIG_fail;
35980 }
35981 resultobj = SWIG_From_int(static_cast< int >(result));
35982 return resultobj;
35983 fail:
35984 return NULL;
35985 }
35986
35987
35988 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35989 PyObject *resultobj = 0;
35990 wxWindow *arg1 = (wxWindow *) 0 ;
35991 wxPoint *arg2 = 0 ;
35992 wxHitTest result;
35993 void *argp1 = 0 ;
35994 int res1 = 0 ;
35995 wxPoint temp2 ;
35996 PyObject * obj0 = 0 ;
35997 PyObject * obj1 = 0 ;
35998 char * kwnames[] = {
35999 (char *) "self",(char *) "pt", NULL
36000 };
36001
36002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36004 if (!SWIG_IsOK(res1)) {
36005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36006 }
36007 arg1 = reinterpret_cast< wxWindow * >(argp1);
36008 {
36009 arg2 = &temp2;
36010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36011 }
36012 {
36013 PyThreadState* __tstate = wxPyBeginAllowThreads();
36014 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 resultobj = SWIG_From_int(static_cast< int >(result));
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36026 PyObject *resultobj = 0;
36027 wxWindow *arg1 = (wxWindow *) 0 ;
36028 long arg2 ;
36029 wxBorder result;
36030 void *argp1 = 0 ;
36031 int res1 = 0 ;
36032 long val2 ;
36033 int ecode2 = 0 ;
36034
36035 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36037 if (!SWIG_IsOK(res1)) {
36038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36039 }
36040 arg1 = reinterpret_cast< wxWindow * >(argp1);
36041 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36042 if (!SWIG_IsOK(ecode2)) {
36043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36044 }
36045 arg2 = static_cast< long >(val2);
36046 {
36047 PyThreadState* __tstate = wxPyBeginAllowThreads();
36048 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 resultobj = SWIG_From_int(static_cast< int >(result));
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36060 PyObject *resultobj = 0;
36061 wxWindow *arg1 = (wxWindow *) 0 ;
36062 wxBorder result;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065
36066 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36070 }
36071 arg1 = reinterpret_cast< wxWindow * >(argp1);
36072 {
36073 PyThreadState* __tstate = wxPyBeginAllowThreads();
36074 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36075 wxPyEndAllowThreads(__tstate);
36076 if (PyErr_Occurred()) SWIG_fail;
36077 }
36078 resultobj = SWIG_From_int(static_cast< int >(result));
36079 return resultobj;
36080 fail:
36081 return NULL;
36082 }
36083
36084
36085 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36086 int argc;
36087 PyObject *argv[3];
36088
36089 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36090 --argc;
36091 if (argc == 1) {
36092 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36093 }
36094 if (argc == 2) {
36095 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36096 }
36097
36098 fail:
36099 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36100 return NULL;
36101 }
36102
36103
36104 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36105 PyObject *resultobj = 0;
36106 wxWindow *arg1 = (wxWindow *) 0 ;
36107 long arg2 = (long) wxUPDATE_UI_NONE ;
36108 void *argp1 = 0 ;
36109 int res1 = 0 ;
36110 long val2 ;
36111 int ecode2 = 0 ;
36112 PyObject * obj0 = 0 ;
36113 PyObject * obj1 = 0 ;
36114 char * kwnames[] = {
36115 (char *) "self",(char *) "flags", NULL
36116 };
36117
36118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36120 if (!SWIG_IsOK(res1)) {
36121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36122 }
36123 arg1 = reinterpret_cast< wxWindow * >(argp1);
36124 if (obj1) {
36125 ecode2 = SWIG_AsVal_long(obj1, &val2);
36126 if (!SWIG_IsOK(ecode2)) {
36127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36128 }
36129 arg2 = static_cast< long >(val2);
36130 }
36131 {
36132 PyThreadState* __tstate = wxPyBeginAllowThreads();
36133 (arg1)->UpdateWindowUI(arg2);
36134 wxPyEndAllowThreads(__tstate);
36135 if (PyErr_Occurred()) SWIG_fail;
36136 }
36137 resultobj = SWIG_Py_Void();
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj = 0;
36146 wxWindow *arg1 = (wxWindow *) 0 ;
36147 wxMenu *arg2 = (wxMenu *) 0 ;
36148 int arg3 = (int) -1 ;
36149 int arg4 = (int) -1 ;
36150 bool result;
36151 void *argp1 = 0 ;
36152 int res1 = 0 ;
36153 void *argp2 = 0 ;
36154 int res2 = 0 ;
36155 int val3 ;
36156 int ecode3 = 0 ;
36157 int val4 ;
36158 int ecode4 = 0 ;
36159 PyObject * obj0 = 0 ;
36160 PyObject * obj1 = 0 ;
36161 PyObject * obj2 = 0 ;
36162 PyObject * obj3 = 0 ;
36163 char * kwnames[] = {
36164 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36165 };
36166
36167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36169 if (!SWIG_IsOK(res1)) {
36170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36171 }
36172 arg1 = reinterpret_cast< wxWindow * >(argp1);
36173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36174 if (!SWIG_IsOK(res2)) {
36175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36176 }
36177 arg2 = reinterpret_cast< wxMenu * >(argp2);
36178 if (obj2) {
36179 ecode3 = SWIG_AsVal_int(obj2, &val3);
36180 if (!SWIG_IsOK(ecode3)) {
36181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36182 }
36183 arg3 = static_cast< int >(val3);
36184 }
36185 if (obj3) {
36186 ecode4 = SWIG_AsVal_int(obj3, &val4);
36187 if (!SWIG_IsOK(ecode4)) {
36188 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36189 }
36190 arg4 = static_cast< int >(val4);
36191 }
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36195 wxPyEndAllowThreads(__tstate);
36196 if (PyErr_Occurred()) SWIG_fail;
36197 }
36198 {
36199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36200 }
36201 return resultobj;
36202 fail:
36203 return NULL;
36204 }
36205
36206
36207 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36208 PyObject *resultobj = 0;
36209 wxWindow *arg1 = (wxWindow *) 0 ;
36210 wxMenu *arg2 = (wxMenu *) 0 ;
36211 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36212 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36213 bool result;
36214 void *argp1 = 0 ;
36215 int res1 = 0 ;
36216 void *argp2 = 0 ;
36217 int res2 = 0 ;
36218 wxPoint temp3 ;
36219 PyObject * obj0 = 0 ;
36220 PyObject * obj1 = 0 ;
36221 PyObject * obj2 = 0 ;
36222 char * kwnames[] = {
36223 (char *) "self",(char *) "menu",(char *) "pos", NULL
36224 };
36225
36226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36228 if (!SWIG_IsOK(res1)) {
36229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36230 }
36231 arg1 = reinterpret_cast< wxWindow * >(argp1);
36232 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36233 if (!SWIG_IsOK(res2)) {
36234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36235 }
36236 arg2 = reinterpret_cast< wxMenu * >(argp2);
36237 if (obj2) {
36238 {
36239 arg3 = &temp3;
36240 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36241 }
36242 }
36243 {
36244 PyThreadState* __tstate = wxPyBeginAllowThreads();
36245 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 {
36250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36251 }
36252 return resultobj;
36253 fail:
36254 return NULL;
36255 }
36256
36257
36258 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36259 PyObject *resultobj = 0;
36260 wxWindow *arg1 = (wxWindow *) 0 ;
36261 long result;
36262 void *argp1 = 0 ;
36263 int res1 = 0 ;
36264 PyObject *swig_obj[1] ;
36265
36266 if (!args) SWIG_fail;
36267 swig_obj[0] = args;
36268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36269 if (!SWIG_IsOK(res1)) {
36270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36271 }
36272 arg1 = reinterpret_cast< wxWindow * >(argp1);
36273 {
36274 PyThreadState* __tstate = wxPyBeginAllowThreads();
36275 result = (long)wxWindow_GetHandle(arg1);
36276 wxPyEndAllowThreads(__tstate);
36277 if (PyErr_Occurred()) SWIG_fail;
36278 }
36279 resultobj = SWIG_From_long(static_cast< long >(result));
36280 return resultobj;
36281 fail:
36282 return NULL;
36283 }
36284
36285
36286 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36287 PyObject *resultobj = 0;
36288 wxWindow *arg1 = (wxWindow *) 0 ;
36289 long arg2 ;
36290 void *argp1 = 0 ;
36291 int res1 = 0 ;
36292 long val2 ;
36293 int ecode2 = 0 ;
36294 PyObject * obj0 = 0 ;
36295 PyObject * obj1 = 0 ;
36296 char * kwnames[] = {
36297 (char *) "self",(char *) "handle", NULL
36298 };
36299
36300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36304 }
36305 arg1 = reinterpret_cast< wxWindow * >(argp1);
36306 ecode2 = SWIG_AsVal_long(obj1, &val2);
36307 if (!SWIG_IsOK(ecode2)) {
36308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36309 }
36310 arg2 = static_cast< long >(val2);
36311 {
36312 PyThreadState* __tstate = wxPyBeginAllowThreads();
36313 wxWindow_AssociateHandle(arg1,arg2);
36314 wxPyEndAllowThreads(__tstate);
36315 if (PyErr_Occurred()) SWIG_fail;
36316 }
36317 resultobj = SWIG_Py_Void();
36318 return resultobj;
36319 fail:
36320 return NULL;
36321 }
36322
36323
36324 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36325 PyObject *resultobj = 0;
36326 wxWindow *arg1 = (wxWindow *) 0 ;
36327 void *argp1 = 0 ;
36328 int res1 = 0 ;
36329 PyObject *swig_obj[1] ;
36330
36331 if (!args) SWIG_fail;
36332 swig_obj[0] = args;
36333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36334 if (!SWIG_IsOK(res1)) {
36335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36336 }
36337 arg1 = reinterpret_cast< wxWindow * >(argp1);
36338 {
36339 PyThreadState* __tstate = wxPyBeginAllowThreads();
36340 (arg1)->DissociateHandle();
36341 wxPyEndAllowThreads(__tstate);
36342 if (PyErr_Occurred()) SWIG_fail;
36343 }
36344 resultobj = SWIG_Py_Void();
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36352 PyObject *resultobj = 0;
36353 wxWindow *arg1 = (wxWindow *) 0 ;
36354 int arg2 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 int val2 ;
36359 int ecode2 = 0 ;
36360 PyObject * obj0 = 0 ;
36361 PyObject * obj1 = 0 ;
36362 char * kwnames[] = {
36363 (char *) "self",(char *) "orient", NULL
36364 };
36365
36366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36368 if (!SWIG_IsOK(res1)) {
36369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36370 }
36371 arg1 = reinterpret_cast< wxWindow * >(argp1);
36372 ecode2 = SWIG_AsVal_int(obj1, &val2);
36373 if (!SWIG_IsOK(ecode2)) {
36374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36375 }
36376 arg2 = static_cast< int >(val2);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 int arg2 ;
36396 int arg3 ;
36397 int arg4 ;
36398 int arg5 ;
36399 bool arg6 = (bool) true ;
36400 void *argp1 = 0 ;
36401 int res1 = 0 ;
36402 int val2 ;
36403 int ecode2 = 0 ;
36404 int val3 ;
36405 int ecode3 = 0 ;
36406 int val4 ;
36407 int ecode4 = 0 ;
36408 int val5 ;
36409 int ecode5 = 0 ;
36410 bool val6 ;
36411 int ecode6 = 0 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 PyObject * obj2 = 0 ;
36415 PyObject * obj3 = 0 ;
36416 PyObject * obj4 = 0 ;
36417 PyObject * obj5 = 0 ;
36418 char * kwnames[] = {
36419 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36420 };
36421
36422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36424 if (!SWIG_IsOK(res1)) {
36425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36426 }
36427 arg1 = reinterpret_cast< wxWindow * >(argp1);
36428 ecode2 = SWIG_AsVal_int(obj1, &val2);
36429 if (!SWIG_IsOK(ecode2)) {
36430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36431 }
36432 arg2 = static_cast< int >(val2);
36433 ecode3 = SWIG_AsVal_int(obj2, &val3);
36434 if (!SWIG_IsOK(ecode3)) {
36435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36436 }
36437 arg3 = static_cast< int >(val3);
36438 ecode4 = SWIG_AsVal_int(obj3, &val4);
36439 if (!SWIG_IsOK(ecode4)) {
36440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36441 }
36442 arg4 = static_cast< int >(val4);
36443 ecode5 = SWIG_AsVal_int(obj4, &val5);
36444 if (!SWIG_IsOK(ecode5)) {
36445 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36446 }
36447 arg5 = static_cast< int >(val5);
36448 if (obj5) {
36449 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36450 if (!SWIG_IsOK(ecode6)) {
36451 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36452 }
36453 arg6 = static_cast< bool >(val6);
36454 }
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36458 wxPyEndAllowThreads(__tstate);
36459 if (PyErr_Occurred()) SWIG_fail;
36460 }
36461 resultobj = SWIG_Py_Void();
36462 return resultobj;
36463 fail:
36464 return NULL;
36465 }
36466
36467
36468 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36469 PyObject *resultobj = 0;
36470 wxWindow *arg1 = (wxWindow *) 0 ;
36471 int arg2 ;
36472 int arg3 ;
36473 bool arg4 = (bool) true ;
36474 void *argp1 = 0 ;
36475 int res1 = 0 ;
36476 int val2 ;
36477 int ecode2 = 0 ;
36478 int val3 ;
36479 int ecode3 = 0 ;
36480 bool val4 ;
36481 int ecode4 = 0 ;
36482 PyObject * obj0 = 0 ;
36483 PyObject * obj1 = 0 ;
36484 PyObject * obj2 = 0 ;
36485 PyObject * obj3 = 0 ;
36486 char * kwnames[] = {
36487 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36488 };
36489
36490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 ecode2 = SWIG_AsVal_int(obj1, &val2);
36497 if (!SWIG_IsOK(ecode2)) {
36498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36499 }
36500 arg2 = static_cast< int >(val2);
36501 ecode3 = SWIG_AsVal_int(obj2, &val3);
36502 if (!SWIG_IsOK(ecode3)) {
36503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36504 }
36505 arg3 = static_cast< int >(val3);
36506 if (obj3) {
36507 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36508 if (!SWIG_IsOK(ecode4)) {
36509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36510 }
36511 arg4 = static_cast< bool >(val4);
36512 }
36513 {
36514 PyThreadState* __tstate = wxPyBeginAllowThreads();
36515 (arg1)->SetScrollPos(arg2,arg3,arg4);
36516 wxPyEndAllowThreads(__tstate);
36517 if (PyErr_Occurred()) SWIG_fail;
36518 }
36519 resultobj = SWIG_Py_Void();
36520 return resultobj;
36521 fail:
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36527 PyObject *resultobj = 0;
36528 wxWindow *arg1 = (wxWindow *) 0 ;
36529 int arg2 ;
36530 int result;
36531 void *argp1 = 0 ;
36532 int res1 = 0 ;
36533 int val2 ;
36534 int ecode2 = 0 ;
36535 PyObject * obj0 = 0 ;
36536 PyObject * obj1 = 0 ;
36537 char * kwnames[] = {
36538 (char *) "self",(char *) "orientation", NULL
36539 };
36540
36541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36543 if (!SWIG_IsOK(res1)) {
36544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36545 }
36546 arg1 = reinterpret_cast< wxWindow * >(argp1);
36547 ecode2 = SWIG_AsVal_int(obj1, &val2);
36548 if (!SWIG_IsOK(ecode2)) {
36549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36550 }
36551 arg2 = static_cast< int >(val2);
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 resultobj = SWIG_From_int(static_cast< int >(result));
36559 return resultobj;
36560 fail:
36561 return NULL;
36562 }
36563
36564
36565 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36566 PyObject *resultobj = 0;
36567 wxWindow *arg1 = (wxWindow *) 0 ;
36568 int arg2 ;
36569 int result;
36570 void *argp1 = 0 ;
36571 int res1 = 0 ;
36572 int val2 ;
36573 int ecode2 = 0 ;
36574 PyObject * obj0 = 0 ;
36575 PyObject * obj1 = 0 ;
36576 char * kwnames[] = {
36577 (char *) "self",(char *) "orientation", NULL
36578 };
36579
36580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36582 if (!SWIG_IsOK(res1)) {
36583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36584 }
36585 arg1 = reinterpret_cast< wxWindow * >(argp1);
36586 ecode2 = SWIG_AsVal_int(obj1, &val2);
36587 if (!SWIG_IsOK(ecode2)) {
36588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36589 }
36590 arg2 = static_cast< int >(val2);
36591 {
36592 PyThreadState* __tstate = wxPyBeginAllowThreads();
36593 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 resultobj = SWIG_From_int(static_cast< int >(result));
36598 return resultobj;
36599 fail:
36600 return NULL;
36601 }
36602
36603
36604 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36605 PyObject *resultobj = 0;
36606 wxWindow *arg1 = (wxWindow *) 0 ;
36607 int arg2 ;
36608 int result;
36609 void *argp1 = 0 ;
36610 int res1 = 0 ;
36611 int val2 ;
36612 int ecode2 = 0 ;
36613 PyObject * obj0 = 0 ;
36614 PyObject * obj1 = 0 ;
36615 char * kwnames[] = {
36616 (char *) "self",(char *) "orientation", NULL
36617 };
36618
36619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36621 if (!SWIG_IsOK(res1)) {
36622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36623 }
36624 arg1 = reinterpret_cast< wxWindow * >(argp1);
36625 ecode2 = SWIG_AsVal_int(obj1, &val2);
36626 if (!SWIG_IsOK(ecode2)) {
36627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36628 }
36629 arg2 = static_cast< int >(val2);
36630 {
36631 PyThreadState* __tstate = wxPyBeginAllowThreads();
36632 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36633 wxPyEndAllowThreads(__tstate);
36634 if (PyErr_Occurred()) SWIG_fail;
36635 }
36636 resultobj = SWIG_From_int(static_cast< int >(result));
36637 return resultobj;
36638 fail:
36639 return NULL;
36640 }
36641
36642
36643 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36644 PyObject *resultobj = 0;
36645 wxWindow *arg1 = (wxWindow *) 0 ;
36646 int arg2 ;
36647 int arg3 ;
36648 wxRect *arg4 = (wxRect *) NULL ;
36649 void *argp1 = 0 ;
36650 int res1 = 0 ;
36651 int val2 ;
36652 int ecode2 = 0 ;
36653 int val3 ;
36654 int ecode3 = 0 ;
36655 void *argp4 = 0 ;
36656 int res4 = 0 ;
36657 PyObject * obj0 = 0 ;
36658 PyObject * obj1 = 0 ;
36659 PyObject * obj2 = 0 ;
36660 PyObject * obj3 = 0 ;
36661 char * kwnames[] = {
36662 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36663 };
36664
36665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 ecode2 = SWIG_AsVal_int(obj1, &val2);
36672 if (!SWIG_IsOK(ecode2)) {
36673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36674 }
36675 arg2 = static_cast< int >(val2);
36676 ecode3 = SWIG_AsVal_int(obj2, &val3);
36677 if (!SWIG_IsOK(ecode3)) {
36678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36679 }
36680 arg3 = static_cast< int >(val3);
36681 if (obj3) {
36682 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36683 if (!SWIG_IsOK(res4)) {
36684 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36685 }
36686 arg4 = reinterpret_cast< wxRect * >(argp4);
36687 }
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 resultobj = SWIG_Py_Void();
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36702 PyObject *resultobj = 0;
36703 wxWindow *arg1 = (wxWindow *) 0 ;
36704 int arg2 ;
36705 bool result;
36706 void *argp1 = 0 ;
36707 int res1 = 0 ;
36708 int val2 ;
36709 int ecode2 = 0 ;
36710 PyObject * obj0 = 0 ;
36711 PyObject * obj1 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "lines", NULL
36714 };
36715
36716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36718 if (!SWIG_IsOK(res1)) {
36719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36720 }
36721 arg1 = reinterpret_cast< wxWindow * >(argp1);
36722 ecode2 = SWIG_AsVal_int(obj1, &val2);
36723 if (!SWIG_IsOK(ecode2)) {
36724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36725 }
36726 arg2 = static_cast< int >(val2);
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 result = (bool)(arg1)->ScrollLines(arg2);
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 {
36734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36735 }
36736 return resultobj;
36737 fail:
36738 return NULL;
36739 }
36740
36741
36742 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36743 PyObject *resultobj = 0;
36744 wxWindow *arg1 = (wxWindow *) 0 ;
36745 int arg2 ;
36746 bool result;
36747 void *argp1 = 0 ;
36748 int res1 = 0 ;
36749 int val2 ;
36750 int ecode2 = 0 ;
36751 PyObject * obj0 = 0 ;
36752 PyObject * obj1 = 0 ;
36753 char * kwnames[] = {
36754 (char *) "self",(char *) "pages", NULL
36755 };
36756
36757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36759 if (!SWIG_IsOK(res1)) {
36760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36761 }
36762 arg1 = reinterpret_cast< wxWindow * >(argp1);
36763 ecode2 = SWIG_AsVal_int(obj1, &val2);
36764 if (!SWIG_IsOK(ecode2)) {
36765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36766 }
36767 arg2 = static_cast< int >(val2);
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 result = (bool)(arg1)->ScrollPages(arg2);
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 {
36775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36776 }
36777 return resultobj;
36778 fail:
36779 return NULL;
36780 }
36781
36782
36783 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36784 PyObject *resultobj = 0;
36785 wxWindow *arg1 = (wxWindow *) 0 ;
36786 bool result;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 PyObject *swig_obj[1] ;
36790
36791 if (!args) SWIG_fail;
36792 swig_obj[0] = args;
36793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = (bool)(arg1)->LineUp();
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36806 }
36807 return resultobj;
36808 fail:
36809 return NULL;
36810 }
36811
36812
36813 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36814 PyObject *resultobj = 0;
36815 wxWindow *arg1 = (wxWindow *) 0 ;
36816 bool result;
36817 void *argp1 = 0 ;
36818 int res1 = 0 ;
36819 PyObject *swig_obj[1] ;
36820
36821 if (!args) SWIG_fail;
36822 swig_obj[0] = args;
36823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36824 if (!SWIG_IsOK(res1)) {
36825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36826 }
36827 arg1 = reinterpret_cast< wxWindow * >(argp1);
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 result = (bool)(arg1)->LineDown();
36831 wxPyEndAllowThreads(__tstate);
36832 if (PyErr_Occurred()) SWIG_fail;
36833 }
36834 {
36835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36836 }
36837 return resultobj;
36838 fail:
36839 return NULL;
36840 }
36841
36842
36843 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36844 PyObject *resultobj = 0;
36845 wxWindow *arg1 = (wxWindow *) 0 ;
36846 bool result;
36847 void *argp1 = 0 ;
36848 int res1 = 0 ;
36849 PyObject *swig_obj[1] ;
36850
36851 if (!args) SWIG_fail;
36852 swig_obj[0] = args;
36853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36854 if (!SWIG_IsOK(res1)) {
36855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36856 }
36857 arg1 = reinterpret_cast< wxWindow * >(argp1);
36858 {
36859 PyThreadState* __tstate = wxPyBeginAllowThreads();
36860 result = (bool)(arg1)->PageUp();
36861 wxPyEndAllowThreads(__tstate);
36862 if (PyErr_Occurred()) SWIG_fail;
36863 }
36864 {
36865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36866 }
36867 return resultobj;
36868 fail:
36869 return NULL;
36870 }
36871
36872
36873 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36874 PyObject *resultobj = 0;
36875 wxWindow *arg1 = (wxWindow *) 0 ;
36876 bool result;
36877 void *argp1 = 0 ;
36878 int res1 = 0 ;
36879 PyObject *swig_obj[1] ;
36880
36881 if (!args) SWIG_fail;
36882 swig_obj[0] = args;
36883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36884 if (!SWIG_IsOK(res1)) {
36885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36886 }
36887 arg1 = reinterpret_cast< wxWindow * >(argp1);
36888 {
36889 PyThreadState* __tstate = wxPyBeginAllowThreads();
36890 result = (bool)(arg1)->PageDown();
36891 wxPyEndAllowThreads(__tstate);
36892 if (PyErr_Occurred()) SWIG_fail;
36893 }
36894 {
36895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36896 }
36897 return resultobj;
36898 fail:
36899 return NULL;
36900 }
36901
36902
36903 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36904 PyObject *resultobj = 0;
36905 wxWindow *arg1 = (wxWindow *) 0 ;
36906 wxString *arg2 = 0 ;
36907 void *argp1 = 0 ;
36908 int res1 = 0 ;
36909 bool temp2 = false ;
36910 PyObject * obj0 = 0 ;
36911 PyObject * obj1 = 0 ;
36912 char * kwnames[] = {
36913 (char *) "self",(char *) "text", NULL
36914 };
36915
36916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 {
36923 arg2 = wxString_in_helper(obj1);
36924 if (arg2 == NULL) SWIG_fail;
36925 temp2 = true;
36926 }
36927 {
36928 PyThreadState* __tstate = wxPyBeginAllowThreads();
36929 (arg1)->SetHelpText((wxString const &)*arg2);
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 resultobj = SWIG_Py_Void();
36934 {
36935 if (temp2)
36936 delete arg2;
36937 }
36938 return resultobj;
36939 fail:
36940 {
36941 if (temp2)
36942 delete arg2;
36943 }
36944 return NULL;
36945 }
36946
36947
36948 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36949 PyObject *resultobj = 0;
36950 wxWindow *arg1 = (wxWindow *) 0 ;
36951 wxString *arg2 = 0 ;
36952 void *argp1 = 0 ;
36953 int res1 = 0 ;
36954 bool temp2 = false ;
36955 PyObject * obj0 = 0 ;
36956 PyObject * obj1 = 0 ;
36957 char * kwnames[] = {
36958 (char *) "self",(char *) "text", NULL
36959 };
36960
36961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36965 }
36966 arg1 = reinterpret_cast< wxWindow * >(argp1);
36967 {
36968 arg2 = wxString_in_helper(obj1);
36969 if (arg2 == NULL) SWIG_fail;
36970 temp2 = true;
36971 }
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 resultobj = SWIG_Py_Void();
36979 {
36980 if (temp2)
36981 delete arg2;
36982 }
36983 return resultobj;
36984 fail:
36985 {
36986 if (temp2)
36987 delete arg2;
36988 }
36989 return NULL;
36990 }
36991
36992
36993 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36994 PyObject *resultobj = 0;
36995 wxWindow *arg1 = (wxWindow *) 0 ;
36996 wxPoint *arg2 = 0 ;
36997 wxHelpEvent::Origin arg3 ;
36998 wxString result;
36999 void *argp1 = 0 ;
37000 int res1 = 0 ;
37001 wxPoint temp2 ;
37002 void *argp3 ;
37003 int res3 = 0 ;
37004 PyObject * obj0 = 0 ;
37005 PyObject * obj1 = 0 ;
37006 PyObject * obj2 = 0 ;
37007 char * kwnames[] = {
37008 (char *) "self",(char *) "pt",(char *) "origin", NULL
37009 };
37010
37011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37013 if (!SWIG_IsOK(res1)) {
37014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37015 }
37016 arg1 = reinterpret_cast< wxWindow * >(argp1);
37017 {
37018 arg2 = &temp2;
37019 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37020 }
37021 {
37022 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37023 if (!SWIG_IsOK(res3)) {
37024 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37025 }
37026 if (!argp3) {
37027 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37028 } else {
37029 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37030 arg3 = *temp;
37031 if (SWIG_IsNewObj(res3)) delete temp;
37032 }
37033 }
37034 {
37035 PyThreadState* __tstate = wxPyBeginAllowThreads();
37036 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37037 wxPyEndAllowThreads(__tstate);
37038 if (PyErr_Occurred()) SWIG_fail;
37039 }
37040 {
37041 #if wxUSE_UNICODE
37042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37043 #else
37044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37045 #endif
37046 }
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 wxString result;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 PyObject *swig_obj[1] ;
37060
37061 if (!args) SWIG_fail;
37062 swig_obj[0] = args;
37063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37064 if (!SWIG_IsOK(res1)) {
37065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37066 }
37067 arg1 = reinterpret_cast< wxWindow * >(argp1);
37068 {
37069 PyThreadState* __tstate = wxPyBeginAllowThreads();
37070 result = ((wxWindow const *)arg1)->GetHelpText();
37071 wxPyEndAllowThreads(__tstate);
37072 if (PyErr_Occurred()) SWIG_fail;
37073 }
37074 {
37075 #if wxUSE_UNICODE
37076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37077 #else
37078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37079 #endif
37080 }
37081 return resultobj;
37082 fail:
37083 return NULL;
37084 }
37085
37086
37087 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37088 PyObject *resultobj = 0;
37089 wxWindow *arg1 = (wxWindow *) 0 ;
37090 wxString *arg2 = 0 ;
37091 void *argp1 = 0 ;
37092 int res1 = 0 ;
37093 bool temp2 = false ;
37094 PyObject * obj0 = 0 ;
37095 PyObject * obj1 = 0 ;
37096 char * kwnames[] = {
37097 (char *) "self",(char *) "tip", NULL
37098 };
37099
37100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37102 if (!SWIG_IsOK(res1)) {
37103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37104 }
37105 arg1 = reinterpret_cast< wxWindow * >(argp1);
37106 {
37107 arg2 = wxString_in_helper(obj1);
37108 if (arg2 == NULL) SWIG_fail;
37109 temp2 = true;
37110 }
37111 {
37112 PyThreadState* __tstate = wxPyBeginAllowThreads();
37113 (arg1)->SetToolTip((wxString const &)*arg2);
37114 wxPyEndAllowThreads(__tstate);
37115 if (PyErr_Occurred()) SWIG_fail;
37116 }
37117 resultobj = SWIG_Py_Void();
37118 {
37119 if (temp2)
37120 delete arg2;
37121 }
37122 return resultobj;
37123 fail:
37124 {
37125 if (temp2)
37126 delete arg2;
37127 }
37128 return NULL;
37129 }
37130
37131
37132 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37133 PyObject *resultobj = 0;
37134 wxWindow *arg1 = (wxWindow *) 0 ;
37135 wxToolTip *arg2 = (wxToolTip *) 0 ;
37136 void *argp1 = 0 ;
37137 int res1 = 0 ;
37138 int res2 = 0 ;
37139 PyObject * obj0 = 0 ;
37140 PyObject * obj1 = 0 ;
37141 char * kwnames[] = {
37142 (char *) "self",(char *) "tip", NULL
37143 };
37144
37145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37147 if (!SWIG_IsOK(res1)) {
37148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37149 }
37150 arg1 = reinterpret_cast< wxWindow * >(argp1);
37151 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37152 if (!SWIG_IsOK(res2)) {
37153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37154 }
37155 {
37156 PyThreadState* __tstate = wxPyBeginAllowThreads();
37157 (arg1)->SetToolTip(arg2);
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 resultobj = SWIG_Py_Void();
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37169 PyObject *resultobj = 0;
37170 wxWindow *arg1 = (wxWindow *) 0 ;
37171 wxToolTip *result = 0 ;
37172 void *argp1 = 0 ;
37173 int res1 = 0 ;
37174 PyObject *swig_obj[1] ;
37175
37176 if (!args) SWIG_fail;
37177 swig_obj[0] = args;
37178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37179 if (!SWIG_IsOK(res1)) {
37180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37181 }
37182 arg1 = reinterpret_cast< wxWindow * >(argp1);
37183 {
37184 PyThreadState* __tstate = wxPyBeginAllowThreads();
37185 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37186 wxPyEndAllowThreads(__tstate);
37187 if (PyErr_Occurred()) SWIG_fail;
37188 }
37189 {
37190 resultobj = wxPyMake_wxObject(result, (bool)0);
37191 }
37192 return resultobj;
37193 fail:
37194 return NULL;
37195 }
37196
37197
37198 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37199 PyObject *resultobj = 0;
37200 wxWindow *arg1 = (wxWindow *) 0 ;
37201 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37202 void *argp1 = 0 ;
37203 int res1 = 0 ;
37204 int res2 = 0 ;
37205 PyObject * obj0 = 0 ;
37206 PyObject * obj1 = 0 ;
37207 char * kwnames[] = {
37208 (char *) "self",(char *) "dropTarget", NULL
37209 };
37210
37211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37213 if (!SWIG_IsOK(res1)) {
37214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37215 }
37216 arg1 = reinterpret_cast< wxWindow * >(argp1);
37217 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37218 if (!SWIG_IsOK(res2)) {
37219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37220 }
37221 {
37222 PyThreadState* __tstate = wxPyBeginAllowThreads();
37223 (arg1)->SetDropTarget(arg2);
37224 wxPyEndAllowThreads(__tstate);
37225 if (PyErr_Occurred()) SWIG_fail;
37226 }
37227 resultobj = SWIG_Py_Void();
37228 return resultobj;
37229 fail:
37230 return NULL;
37231 }
37232
37233
37234 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37235 PyObject *resultobj = 0;
37236 wxWindow *arg1 = (wxWindow *) 0 ;
37237 wxPyDropTarget *result = 0 ;
37238 void *argp1 = 0 ;
37239 int res1 = 0 ;
37240 PyObject *swig_obj[1] ;
37241
37242 if (!args) SWIG_fail;
37243 swig_obj[0] = args;
37244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37245 if (!SWIG_IsOK(res1)) {
37246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37247 }
37248 arg1 = reinterpret_cast< wxWindow * >(argp1);
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37252 wxPyEndAllowThreads(__tstate);
37253 if (PyErr_Occurred()) SWIG_fail;
37254 }
37255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37256 return resultobj;
37257 fail:
37258 return NULL;
37259 }
37260
37261
37262 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37263 PyObject *resultobj = 0;
37264 wxWindow *arg1 = (wxWindow *) 0 ;
37265 bool arg2 ;
37266 void *argp1 = 0 ;
37267 int res1 = 0 ;
37268 bool val2 ;
37269 int ecode2 = 0 ;
37270 PyObject * obj0 = 0 ;
37271 PyObject * obj1 = 0 ;
37272 char * kwnames[] = {
37273 (char *) "self",(char *) "accept", NULL
37274 };
37275
37276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37278 if (!SWIG_IsOK(res1)) {
37279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37280 }
37281 arg1 = reinterpret_cast< wxWindow * >(argp1);
37282 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37283 if (!SWIG_IsOK(ecode2)) {
37284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37285 }
37286 arg2 = static_cast< bool >(val2);
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 wxWindow_DragAcceptFiles(arg1,arg2);
37290 wxPyEndAllowThreads(__tstate);
37291 if (PyErr_Occurred()) SWIG_fail;
37292 }
37293 resultobj = SWIG_Py_Void();
37294 return resultobj;
37295 fail:
37296 return NULL;
37297 }
37298
37299
37300 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37301 PyObject *resultobj = 0;
37302 wxWindow *arg1 = (wxWindow *) 0 ;
37303 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 int res2 = 0 ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "constraints", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37322 }
37323 {
37324 PyThreadState* __tstate = wxPyBeginAllowThreads();
37325 (arg1)->SetConstraints(arg2);
37326 wxPyEndAllowThreads(__tstate);
37327 if (PyErr_Occurred()) SWIG_fail;
37328 }
37329 resultobj = SWIG_Py_Void();
37330 return resultobj;
37331 fail:
37332 return NULL;
37333 }
37334
37335
37336 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37337 PyObject *resultobj = 0;
37338 wxWindow *arg1 = (wxWindow *) 0 ;
37339 wxLayoutConstraints *result = 0 ;
37340 void *argp1 = 0 ;
37341 int res1 = 0 ;
37342 PyObject *swig_obj[1] ;
37343
37344 if (!args) SWIG_fail;
37345 swig_obj[0] = args;
37346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37347 if (!SWIG_IsOK(res1)) {
37348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37349 }
37350 arg1 = reinterpret_cast< wxWindow * >(argp1);
37351 {
37352 PyThreadState* __tstate = wxPyBeginAllowThreads();
37353 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37358 return resultobj;
37359 fail:
37360 return NULL;
37361 }
37362
37363
37364 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37365 PyObject *resultobj = 0;
37366 wxWindow *arg1 = (wxWindow *) 0 ;
37367 bool arg2 ;
37368 void *argp1 = 0 ;
37369 int res1 = 0 ;
37370 bool val2 ;
37371 int ecode2 = 0 ;
37372 PyObject * obj0 = 0 ;
37373 PyObject * obj1 = 0 ;
37374 char * kwnames[] = {
37375 (char *) "self",(char *) "autoLayout", NULL
37376 };
37377
37378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37380 if (!SWIG_IsOK(res1)) {
37381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37382 }
37383 arg1 = reinterpret_cast< wxWindow * >(argp1);
37384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37385 if (!SWIG_IsOK(ecode2)) {
37386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37387 }
37388 arg2 = static_cast< bool >(val2);
37389 {
37390 PyThreadState* __tstate = wxPyBeginAllowThreads();
37391 (arg1)->SetAutoLayout(arg2);
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 resultobj = SWIG_Py_Void();
37396 return resultobj;
37397 fail:
37398 return NULL;
37399 }
37400
37401
37402 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37403 PyObject *resultobj = 0;
37404 wxWindow *arg1 = (wxWindow *) 0 ;
37405 bool result;
37406 void *argp1 = 0 ;
37407 int res1 = 0 ;
37408 PyObject *swig_obj[1] ;
37409
37410 if (!args) SWIG_fail;
37411 swig_obj[0] = args;
37412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37413 if (!SWIG_IsOK(res1)) {
37414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37415 }
37416 arg1 = reinterpret_cast< wxWindow * >(argp1);
37417 {
37418 PyThreadState* __tstate = wxPyBeginAllowThreads();
37419 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37420 wxPyEndAllowThreads(__tstate);
37421 if (PyErr_Occurred()) SWIG_fail;
37422 }
37423 {
37424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37425 }
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 bool result;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 PyObject *swig_obj[1] ;
37439
37440 if (!args) SWIG_fail;
37441 swig_obj[0] = args;
37442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37445 }
37446 arg1 = reinterpret_cast< wxWindow * >(argp1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (bool)(arg1)->Layout();
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 {
37454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37455 }
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37463 PyObject *resultobj = 0;
37464 wxWindow *arg1 = (wxWindow *) 0 ;
37465 wxSizer *arg2 = (wxSizer *) 0 ;
37466 bool arg3 = (bool) true ;
37467 void *argp1 = 0 ;
37468 int res1 = 0 ;
37469 int res2 = 0 ;
37470 bool val3 ;
37471 int ecode3 = 0 ;
37472 PyObject * obj0 = 0 ;
37473 PyObject * obj1 = 0 ;
37474 PyObject * obj2 = 0 ;
37475 char * kwnames[] = {
37476 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37477 };
37478
37479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37481 if (!SWIG_IsOK(res1)) {
37482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37483 }
37484 arg1 = reinterpret_cast< wxWindow * >(argp1);
37485 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37486 if (!SWIG_IsOK(res2)) {
37487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37488 }
37489 if (obj2) {
37490 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37491 if (!SWIG_IsOK(ecode3)) {
37492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37493 }
37494 arg3 = static_cast< bool >(val3);
37495 }
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 (arg1)->SetSizer(arg2,arg3);
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 resultobj = SWIG_Py_Void();
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37510 PyObject *resultobj = 0;
37511 wxWindow *arg1 = (wxWindow *) 0 ;
37512 wxSizer *arg2 = (wxSizer *) 0 ;
37513 bool arg3 = (bool) true ;
37514 void *argp1 = 0 ;
37515 int res1 = 0 ;
37516 int res2 = 0 ;
37517 bool val3 ;
37518 int ecode3 = 0 ;
37519 PyObject * obj0 = 0 ;
37520 PyObject * obj1 = 0 ;
37521 PyObject * obj2 = 0 ;
37522 char * kwnames[] = {
37523 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37524 };
37525
37526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37528 if (!SWIG_IsOK(res1)) {
37529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37530 }
37531 arg1 = reinterpret_cast< wxWindow * >(argp1);
37532 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37533 if (!SWIG_IsOK(res2)) {
37534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37535 }
37536 if (obj2) {
37537 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37538 if (!SWIG_IsOK(ecode3)) {
37539 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37540 }
37541 arg3 = static_cast< bool >(val3);
37542 }
37543 {
37544 PyThreadState* __tstate = wxPyBeginAllowThreads();
37545 (arg1)->SetSizerAndFit(arg2,arg3);
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 resultobj = SWIG_Py_Void();
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 wxWindow *arg1 = (wxWindow *) 0 ;
37559 wxSizer *result = 0 ;
37560 void *argp1 = 0 ;
37561 int res1 = 0 ;
37562 PyObject *swig_obj[1] ;
37563
37564 if (!args) SWIG_fail;
37565 swig_obj[0] = args;
37566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37567 if (!SWIG_IsOK(res1)) {
37568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37569 }
37570 arg1 = reinterpret_cast< wxWindow * >(argp1);
37571 {
37572 PyThreadState* __tstate = wxPyBeginAllowThreads();
37573 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37574 wxPyEndAllowThreads(__tstate);
37575 if (PyErr_Occurred()) SWIG_fail;
37576 }
37577 {
37578 resultobj = wxPyMake_wxObject(result, (bool)0);
37579 }
37580 return resultobj;
37581 fail:
37582 return NULL;
37583 }
37584
37585
37586 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37587 PyObject *resultobj = 0;
37588 wxWindow *arg1 = (wxWindow *) 0 ;
37589 wxSizer *arg2 = (wxSizer *) 0 ;
37590 void *argp1 = 0 ;
37591 int res1 = 0 ;
37592 void *argp2 = 0 ;
37593 int res2 = 0 ;
37594 PyObject * obj0 = 0 ;
37595 PyObject * obj1 = 0 ;
37596 char * kwnames[] = {
37597 (char *) "self",(char *) "sizer", NULL
37598 };
37599
37600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37602 if (!SWIG_IsOK(res1)) {
37603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37604 }
37605 arg1 = reinterpret_cast< wxWindow * >(argp1);
37606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37607 if (!SWIG_IsOK(res2)) {
37608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37609 }
37610 arg2 = reinterpret_cast< wxSizer * >(argp2);
37611 {
37612 PyThreadState* __tstate = wxPyBeginAllowThreads();
37613 (arg1)->SetContainingSizer(arg2);
37614 wxPyEndAllowThreads(__tstate);
37615 if (PyErr_Occurred()) SWIG_fail;
37616 }
37617 resultobj = SWIG_Py_Void();
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37625 PyObject *resultobj = 0;
37626 wxWindow *arg1 = (wxWindow *) 0 ;
37627 wxSizer *result = 0 ;
37628 void *argp1 = 0 ;
37629 int res1 = 0 ;
37630 PyObject *swig_obj[1] ;
37631
37632 if (!args) SWIG_fail;
37633 swig_obj[0] = args;
37634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37635 if (!SWIG_IsOK(res1)) {
37636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37637 }
37638 arg1 = reinterpret_cast< wxWindow * >(argp1);
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 {
37646 resultobj = wxPyMake_wxObject(result, (bool)0);
37647 }
37648 return resultobj;
37649 fail:
37650 return NULL;
37651 }
37652
37653
37654 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37655 PyObject *resultobj = 0;
37656 wxWindow *arg1 = (wxWindow *) 0 ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 PyObject *swig_obj[1] ;
37660
37661 if (!args) SWIG_fail;
37662 swig_obj[0] = args;
37663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37664 if (!SWIG_IsOK(res1)) {
37665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37666 }
37667 arg1 = reinterpret_cast< wxWindow * >(argp1);
37668 {
37669 PyThreadState* __tstate = wxPyBeginAllowThreads();
37670 (arg1)->InheritAttributes();
37671 wxPyEndAllowThreads(__tstate);
37672 if (PyErr_Occurred()) SWIG_fail;
37673 }
37674 resultobj = SWIG_Py_Void();
37675 return resultobj;
37676 fail:
37677 return NULL;
37678 }
37679
37680
37681 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37682 PyObject *resultobj = 0;
37683 wxWindow *arg1 = (wxWindow *) 0 ;
37684 bool result;
37685 void *argp1 = 0 ;
37686 int res1 = 0 ;
37687 PyObject *swig_obj[1] ;
37688
37689 if (!args) SWIG_fail;
37690 swig_obj[0] = args;
37691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37692 if (!SWIG_IsOK(res1)) {
37693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37694 }
37695 arg1 = reinterpret_cast< wxWindow * >(argp1);
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37699 wxPyEndAllowThreads(__tstate);
37700 if (PyErr_Occurred()) SWIG_fail;
37701 }
37702 {
37703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37704 }
37705 return resultobj;
37706 fail:
37707 return NULL;
37708 }
37709
37710
37711 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37712 PyObject *obj;
37713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37714 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37715 return SWIG_Py_Void();
37716 }
37717
37718 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37719 return SWIG_Python_InitShadowInstance(args);
37720 }
37721
37722 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37723 PyObject *resultobj = 0;
37724 long arg1 ;
37725 wxWindow *arg2 = (wxWindow *) NULL ;
37726 wxWindow *result = 0 ;
37727 long val1 ;
37728 int ecode1 = 0 ;
37729 void *argp2 = 0 ;
37730 int res2 = 0 ;
37731 PyObject * obj0 = 0 ;
37732 PyObject * obj1 = 0 ;
37733 char * kwnames[] = {
37734 (char *) "id",(char *) "parent", NULL
37735 };
37736
37737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37738 ecode1 = SWIG_AsVal_long(obj0, &val1);
37739 if (!SWIG_IsOK(ecode1)) {
37740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37741 }
37742 arg1 = static_cast< long >(val1);
37743 if (obj1) {
37744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37745 if (!SWIG_IsOK(res2)) {
37746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37747 }
37748 arg2 = reinterpret_cast< wxWindow * >(argp2);
37749 }
37750 {
37751 if (!wxPyCheckForApp()) SWIG_fail;
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 resultobj = wxPyMake_wxObject(result, 0);
37759 }
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj = 0;
37768 wxString *arg1 = 0 ;
37769 wxWindow *arg2 = (wxWindow *) NULL ;
37770 wxWindow *result = 0 ;
37771 bool temp1 = false ;
37772 void *argp2 = 0 ;
37773 int res2 = 0 ;
37774 PyObject * obj0 = 0 ;
37775 PyObject * obj1 = 0 ;
37776 char * kwnames[] = {
37777 (char *) "name",(char *) "parent", NULL
37778 };
37779
37780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37781 {
37782 arg1 = wxString_in_helper(obj0);
37783 if (arg1 == NULL) SWIG_fail;
37784 temp1 = true;
37785 }
37786 if (obj1) {
37787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37788 if (!SWIG_IsOK(res2)) {
37789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37790 }
37791 arg2 = reinterpret_cast< wxWindow * >(argp2);
37792 }
37793 {
37794 if (!wxPyCheckForApp()) SWIG_fail;
37795 PyThreadState* __tstate = wxPyBeginAllowThreads();
37796 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37797 wxPyEndAllowThreads(__tstate);
37798 if (PyErr_Occurred()) SWIG_fail;
37799 }
37800 {
37801 resultobj = wxPyMake_wxObject(result, 0);
37802 }
37803 {
37804 if (temp1)
37805 delete arg1;
37806 }
37807 return resultobj;
37808 fail:
37809 {
37810 if (temp1)
37811 delete arg1;
37812 }
37813 return NULL;
37814 }
37815
37816
37817 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37818 PyObject *resultobj = 0;
37819 wxString *arg1 = 0 ;
37820 wxWindow *arg2 = (wxWindow *) NULL ;
37821 wxWindow *result = 0 ;
37822 bool temp1 = false ;
37823 void *argp2 = 0 ;
37824 int res2 = 0 ;
37825 PyObject * obj0 = 0 ;
37826 PyObject * obj1 = 0 ;
37827 char * kwnames[] = {
37828 (char *) "label",(char *) "parent", NULL
37829 };
37830
37831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37832 {
37833 arg1 = wxString_in_helper(obj0);
37834 if (arg1 == NULL) SWIG_fail;
37835 temp1 = true;
37836 }
37837 if (obj1) {
37838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37839 if (!SWIG_IsOK(res2)) {
37840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37841 }
37842 arg2 = reinterpret_cast< wxWindow * >(argp2);
37843 }
37844 {
37845 if (!wxPyCheckForApp()) SWIG_fail;
37846 PyThreadState* __tstate = wxPyBeginAllowThreads();
37847 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37848 wxPyEndAllowThreads(__tstate);
37849 if (PyErr_Occurred()) SWIG_fail;
37850 }
37851 {
37852 resultobj = wxPyMake_wxObject(result, 0);
37853 }
37854 {
37855 if (temp1)
37856 delete arg1;
37857 }
37858 return resultobj;
37859 fail:
37860 {
37861 if (temp1)
37862 delete arg1;
37863 }
37864 return NULL;
37865 }
37866
37867
37868 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37869 PyObject *resultobj = 0;
37870 wxWindow *arg1 = (wxWindow *) 0 ;
37871 unsigned long arg2 ;
37872 wxWindow *result = 0 ;
37873 void *argp1 = 0 ;
37874 int res1 = 0 ;
37875 unsigned long val2 ;
37876 int ecode2 = 0 ;
37877 PyObject * obj0 = 0 ;
37878 PyObject * obj1 = 0 ;
37879 char * kwnames[] = {
37880 (char *) "parent",(char *) "_hWnd", NULL
37881 };
37882
37883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37885 if (!SWIG_IsOK(res1)) {
37886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37887 }
37888 arg1 = reinterpret_cast< wxWindow * >(argp1);
37889 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37890 if (!SWIG_IsOK(ecode2)) {
37891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37892 }
37893 arg2 = static_cast< unsigned long >(val2);
37894 {
37895 PyThreadState* __tstate = wxPyBeginAllowThreads();
37896 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37897 wxPyEndAllowThreads(__tstate);
37898 if (PyErr_Occurred()) SWIG_fail;
37899 }
37900 {
37901 resultobj = wxPyMake_wxObject(result, 0);
37902 }
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37910 PyObject *resultobj = 0;
37911 PyObject *result = 0 ;
37912
37913 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37914 {
37915 PyThreadState* __tstate = wxPyBeginAllowThreads();
37916 result = (PyObject *)GetTopLevelWindows();
37917 wxPyEndAllowThreads(__tstate);
37918 if (PyErr_Occurred()) SWIG_fail;
37919 }
37920 resultobj = result;
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37928 PyObject *resultobj = 0;
37929 wxValidator *result = 0 ;
37930
37931 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37932 {
37933 PyThreadState* __tstate = wxPyBeginAllowThreads();
37934 result = (wxValidator *)new wxValidator();
37935 wxPyEndAllowThreads(__tstate);
37936 if (PyErr_Occurred()) SWIG_fail;
37937 }
37938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37939 return resultobj;
37940 fail:
37941 return NULL;
37942 }
37943
37944
37945 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37946 PyObject *resultobj = 0;
37947 wxValidator *arg1 = (wxValidator *) 0 ;
37948 wxValidator *result = 0 ;
37949 void *argp1 = 0 ;
37950 int res1 = 0 ;
37951 PyObject *swig_obj[1] ;
37952
37953 if (!args) SWIG_fail;
37954 swig_obj[0] = args;
37955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37956 if (!SWIG_IsOK(res1)) {
37957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37958 }
37959 arg1 = reinterpret_cast< wxValidator * >(argp1);
37960 {
37961 PyThreadState* __tstate = wxPyBeginAllowThreads();
37962 result = (wxValidator *)(arg1)->Clone();
37963 wxPyEndAllowThreads(__tstate);
37964 if (PyErr_Occurred()) SWIG_fail;
37965 }
37966 {
37967 resultobj = wxPyMake_wxObject(result, 0);
37968 }
37969 return resultobj;
37970 fail:
37971 return NULL;
37972 }
37973
37974
37975 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37976 PyObject *resultobj = 0;
37977 wxValidator *arg1 = (wxValidator *) 0 ;
37978 wxWindow *arg2 = (wxWindow *) 0 ;
37979 bool result;
37980 void *argp1 = 0 ;
37981 int res1 = 0 ;
37982 void *argp2 = 0 ;
37983 int res2 = 0 ;
37984 PyObject * obj0 = 0 ;
37985 PyObject * obj1 = 0 ;
37986 char * kwnames[] = {
37987 (char *) "self",(char *) "parent", NULL
37988 };
37989
37990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37992 if (!SWIG_IsOK(res1)) {
37993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37994 }
37995 arg1 = reinterpret_cast< wxValidator * >(argp1);
37996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37997 if (!SWIG_IsOK(res2)) {
37998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37999 }
38000 arg2 = reinterpret_cast< wxWindow * >(argp2);
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (bool)(arg1)->Validate(arg2);
38004 wxPyEndAllowThreads(__tstate);
38005 if (PyErr_Occurred()) SWIG_fail;
38006 }
38007 {
38008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38009 }
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38017 PyObject *resultobj = 0;
38018 wxValidator *arg1 = (wxValidator *) 0 ;
38019 bool result;
38020 void *argp1 = 0 ;
38021 int res1 = 0 ;
38022 PyObject *swig_obj[1] ;
38023
38024 if (!args) SWIG_fail;
38025 swig_obj[0] = args;
38026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38027 if (!SWIG_IsOK(res1)) {
38028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38029 }
38030 arg1 = reinterpret_cast< wxValidator * >(argp1);
38031 {
38032 PyThreadState* __tstate = wxPyBeginAllowThreads();
38033 result = (bool)(arg1)->TransferToWindow();
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 {
38038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38039 }
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38047 PyObject *resultobj = 0;
38048 wxValidator *arg1 = (wxValidator *) 0 ;
38049 bool result;
38050 void *argp1 = 0 ;
38051 int res1 = 0 ;
38052 PyObject *swig_obj[1] ;
38053
38054 if (!args) SWIG_fail;
38055 swig_obj[0] = args;
38056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38057 if (!SWIG_IsOK(res1)) {
38058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38059 }
38060 arg1 = reinterpret_cast< wxValidator * >(argp1);
38061 {
38062 PyThreadState* __tstate = wxPyBeginAllowThreads();
38063 result = (bool)(arg1)->TransferFromWindow();
38064 wxPyEndAllowThreads(__tstate);
38065 if (PyErr_Occurred()) SWIG_fail;
38066 }
38067 {
38068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38069 }
38070 return resultobj;
38071 fail:
38072 return NULL;
38073 }
38074
38075
38076 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38077 PyObject *resultobj = 0;
38078 wxValidator *arg1 = (wxValidator *) 0 ;
38079 wxWindow *result = 0 ;
38080 void *argp1 = 0 ;
38081 int res1 = 0 ;
38082 PyObject *swig_obj[1] ;
38083
38084 if (!args) SWIG_fail;
38085 swig_obj[0] = args;
38086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38087 if (!SWIG_IsOK(res1)) {
38088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38089 }
38090 arg1 = reinterpret_cast< wxValidator * >(argp1);
38091 {
38092 PyThreadState* __tstate = wxPyBeginAllowThreads();
38093 result = (wxWindow *)(arg1)->GetWindow();
38094 wxPyEndAllowThreads(__tstate);
38095 if (PyErr_Occurred()) SWIG_fail;
38096 }
38097 {
38098 resultobj = wxPyMake_wxObject(result, 0);
38099 }
38100 return resultobj;
38101 fail:
38102 return NULL;
38103 }
38104
38105
38106 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38107 PyObject *resultobj = 0;
38108 wxValidator *arg1 = (wxValidator *) 0 ;
38109 wxWindow *arg2 = (wxWindow *) 0 ;
38110 void *argp1 = 0 ;
38111 int res1 = 0 ;
38112 void *argp2 = 0 ;
38113 int res2 = 0 ;
38114 PyObject * obj0 = 0 ;
38115 PyObject * obj1 = 0 ;
38116 char * kwnames[] = {
38117 (char *) "self",(char *) "window", NULL
38118 };
38119
38120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38122 if (!SWIG_IsOK(res1)) {
38123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38124 }
38125 arg1 = reinterpret_cast< wxValidator * >(argp1);
38126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38127 if (!SWIG_IsOK(res2)) {
38128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38129 }
38130 arg2 = reinterpret_cast< wxWindow * >(argp2);
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 (arg1)->SetWindow(arg2);
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 resultobj = SWIG_Py_Void();
38138 return resultobj;
38139 fail:
38140 return NULL;
38141 }
38142
38143
38144 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38145 PyObject *resultobj = 0;
38146 bool result;
38147
38148 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 result = (bool)wxValidator::IsSilent();
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 {
38156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38157 }
38158 return resultobj;
38159 fail:
38160 return NULL;
38161 }
38162
38163
38164 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38165 PyObject *resultobj = 0;
38166 int arg1 = (int) true ;
38167 int val1 ;
38168 int ecode1 = 0 ;
38169 PyObject * obj0 = 0 ;
38170 char * kwnames[] = {
38171 (char *) "doIt", NULL
38172 };
38173
38174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38175 if (obj0) {
38176 ecode1 = SWIG_AsVal_int(obj0, &val1);
38177 if (!SWIG_IsOK(ecode1)) {
38178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38179 }
38180 arg1 = static_cast< int >(val1);
38181 }
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 wxValidator::SetBellOnError(arg1);
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 resultobj = SWIG_Py_Void();
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38196 PyObject *obj;
38197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38198 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38199 return SWIG_Py_Void();
38200 }
38201
38202 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38203 return SWIG_Python_InitShadowInstance(args);
38204 }
38205
38206 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38207 PyObject *resultobj = 0;
38208 wxPyValidator *result = 0 ;
38209
38210 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38211 {
38212 PyThreadState* __tstate = wxPyBeginAllowThreads();
38213 result = (wxPyValidator *)new wxPyValidator();
38214 wxPyEndAllowThreads(__tstate);
38215 if (PyErr_Occurred()) SWIG_fail;
38216 }
38217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38218 return resultobj;
38219 fail:
38220 return NULL;
38221 }
38222
38223
38224 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38225 PyObject *resultobj = 0;
38226 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38227 PyObject *arg2 = (PyObject *) 0 ;
38228 PyObject *arg3 = (PyObject *) 0 ;
38229 int arg4 = (int) true ;
38230 void *argp1 = 0 ;
38231 int res1 = 0 ;
38232 int val4 ;
38233 int ecode4 = 0 ;
38234 PyObject * obj0 = 0 ;
38235 PyObject * obj1 = 0 ;
38236 PyObject * obj2 = 0 ;
38237 PyObject * obj3 = 0 ;
38238 char * kwnames[] = {
38239 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38240 };
38241
38242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38244 if (!SWIG_IsOK(res1)) {
38245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38246 }
38247 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38248 arg2 = obj1;
38249 arg3 = obj2;
38250 if (obj3) {
38251 ecode4 = SWIG_AsVal_int(obj3, &val4);
38252 if (!SWIG_IsOK(ecode4)) {
38253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38254 }
38255 arg4 = static_cast< int >(val4);
38256 }
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38260 wxPyEndAllowThreads(__tstate);
38261 if (PyErr_Occurred()) SWIG_fail;
38262 }
38263 resultobj = SWIG_Py_Void();
38264 return resultobj;
38265 fail:
38266 return NULL;
38267 }
38268
38269
38270 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38271 PyObject *obj;
38272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38273 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38274 return SWIG_Py_Void();
38275 }
38276
38277 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38278 return SWIG_Python_InitShadowInstance(args);
38279 }
38280
38281 SWIGINTERN int DefaultValidator_set(PyObject *) {
38282 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38283 return 1;
38284 }
38285
38286
38287 SWIGINTERN PyObject *DefaultValidator_get(void) {
38288 PyObject *pyobj = 0;
38289
38290 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38291 return pyobj;
38292 }
38293
38294
38295 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38296 PyObject *resultobj = 0;
38297 wxString const &arg1_defvalue = wxPyEmptyString ;
38298 wxString *arg1 = (wxString *) &arg1_defvalue ;
38299 long arg2 = (long) 0 ;
38300 wxMenu *result = 0 ;
38301 bool temp1 = false ;
38302 long val2 ;
38303 int ecode2 = 0 ;
38304 PyObject * obj0 = 0 ;
38305 PyObject * obj1 = 0 ;
38306 char * kwnames[] = {
38307 (char *) "title",(char *) "style", NULL
38308 };
38309
38310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38311 if (obj0) {
38312 {
38313 arg1 = wxString_in_helper(obj0);
38314 if (arg1 == NULL) SWIG_fail;
38315 temp1 = true;
38316 }
38317 }
38318 if (obj1) {
38319 ecode2 = SWIG_AsVal_long(obj1, &val2);
38320 if (!SWIG_IsOK(ecode2)) {
38321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38322 }
38323 arg2 = static_cast< long >(val2);
38324 }
38325 {
38326 if (!wxPyCheckForApp()) SWIG_fail;
38327 PyThreadState* __tstate = wxPyBeginAllowThreads();
38328 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38333 {
38334 if (temp1)
38335 delete arg1;
38336 }
38337 return resultobj;
38338 fail:
38339 {
38340 if (temp1)
38341 delete arg1;
38342 }
38343 return NULL;
38344 }
38345
38346
38347 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38348 PyObject *resultobj = 0;
38349 wxMenu *arg1 = (wxMenu *) 0 ;
38350 int arg2 ;
38351 wxString *arg3 = 0 ;
38352 wxString const &arg4_defvalue = wxPyEmptyString ;
38353 wxString *arg4 = (wxString *) &arg4_defvalue ;
38354 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38355 wxMenuItem *result = 0 ;
38356 void *argp1 = 0 ;
38357 int res1 = 0 ;
38358 int val2 ;
38359 int ecode2 = 0 ;
38360 bool temp3 = false ;
38361 bool temp4 = false ;
38362 int val5 ;
38363 int ecode5 = 0 ;
38364 PyObject * obj0 = 0 ;
38365 PyObject * obj1 = 0 ;
38366 PyObject * obj2 = 0 ;
38367 PyObject * obj3 = 0 ;
38368 PyObject * obj4 = 0 ;
38369 char * kwnames[] = {
38370 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38371 };
38372
38373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38375 if (!SWIG_IsOK(res1)) {
38376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38377 }
38378 arg1 = reinterpret_cast< wxMenu * >(argp1);
38379 ecode2 = SWIG_AsVal_int(obj1, &val2);
38380 if (!SWIG_IsOK(ecode2)) {
38381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38382 }
38383 arg2 = static_cast< int >(val2);
38384 {
38385 arg3 = wxString_in_helper(obj2);
38386 if (arg3 == NULL) SWIG_fail;
38387 temp3 = true;
38388 }
38389 if (obj3) {
38390 {
38391 arg4 = wxString_in_helper(obj3);
38392 if (arg4 == NULL) SWIG_fail;
38393 temp4 = true;
38394 }
38395 }
38396 if (obj4) {
38397 ecode5 = SWIG_AsVal_int(obj4, &val5);
38398 if (!SWIG_IsOK(ecode5)) {
38399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38400 }
38401 arg5 = static_cast< wxItemKind >(val5);
38402 }
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38406 wxPyEndAllowThreads(__tstate);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 }
38409 {
38410 resultobj = wxPyMake_wxObject(result, (bool)0);
38411 }
38412 {
38413 if (temp3)
38414 delete arg3;
38415 }
38416 {
38417 if (temp4)
38418 delete arg4;
38419 }
38420 return resultobj;
38421 fail:
38422 {
38423 if (temp3)
38424 delete arg3;
38425 }
38426 {
38427 if (temp4)
38428 delete arg4;
38429 }
38430 return NULL;
38431 }
38432
38433
38434 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38435 PyObject *resultobj = 0;
38436 wxMenu *arg1 = (wxMenu *) 0 ;
38437 wxMenuItem *result = 0 ;
38438 void *argp1 = 0 ;
38439 int res1 = 0 ;
38440 PyObject *swig_obj[1] ;
38441
38442 if (!args) SWIG_fail;
38443 swig_obj[0] = args;
38444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38445 if (!SWIG_IsOK(res1)) {
38446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38447 }
38448 arg1 = reinterpret_cast< wxMenu * >(argp1);
38449 {
38450 PyThreadState* __tstate = wxPyBeginAllowThreads();
38451 result = (wxMenuItem *)(arg1)->AppendSeparator();
38452 wxPyEndAllowThreads(__tstate);
38453 if (PyErr_Occurred()) SWIG_fail;
38454 }
38455 {
38456 resultobj = wxPyMake_wxObject(result, (bool)0);
38457 }
38458 return resultobj;
38459 fail:
38460 return NULL;
38461 }
38462
38463
38464 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38465 PyObject *resultobj = 0;
38466 wxMenu *arg1 = (wxMenu *) 0 ;
38467 int arg2 ;
38468 wxString *arg3 = 0 ;
38469 wxString const &arg4_defvalue = wxPyEmptyString ;
38470 wxString *arg4 = (wxString *) &arg4_defvalue ;
38471 wxMenuItem *result = 0 ;
38472 void *argp1 = 0 ;
38473 int res1 = 0 ;
38474 int val2 ;
38475 int ecode2 = 0 ;
38476 bool temp3 = false ;
38477 bool temp4 = false ;
38478 PyObject * obj0 = 0 ;
38479 PyObject * obj1 = 0 ;
38480 PyObject * obj2 = 0 ;
38481 PyObject * obj3 = 0 ;
38482 char * kwnames[] = {
38483 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38484 };
38485
38486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38488 if (!SWIG_IsOK(res1)) {
38489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38490 }
38491 arg1 = reinterpret_cast< wxMenu * >(argp1);
38492 ecode2 = SWIG_AsVal_int(obj1, &val2);
38493 if (!SWIG_IsOK(ecode2)) {
38494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38495 }
38496 arg2 = static_cast< int >(val2);
38497 {
38498 arg3 = wxString_in_helper(obj2);
38499 if (arg3 == NULL) SWIG_fail;
38500 temp3 = true;
38501 }
38502 if (obj3) {
38503 {
38504 arg4 = wxString_in_helper(obj3);
38505 if (arg4 == NULL) SWIG_fail;
38506 temp4 = true;
38507 }
38508 }
38509 {
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38512 wxPyEndAllowThreads(__tstate);
38513 if (PyErr_Occurred()) SWIG_fail;
38514 }
38515 {
38516 resultobj = wxPyMake_wxObject(result, (bool)0);
38517 }
38518 {
38519 if (temp3)
38520 delete arg3;
38521 }
38522 {
38523 if (temp4)
38524 delete arg4;
38525 }
38526 return resultobj;
38527 fail:
38528 {
38529 if (temp3)
38530 delete arg3;
38531 }
38532 {
38533 if (temp4)
38534 delete arg4;
38535 }
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = 0;
38542 wxMenu *arg1 = (wxMenu *) 0 ;
38543 int arg2 ;
38544 wxString *arg3 = 0 ;
38545 wxString const &arg4_defvalue = wxPyEmptyString ;
38546 wxString *arg4 = (wxString *) &arg4_defvalue ;
38547 wxMenuItem *result = 0 ;
38548 void *argp1 = 0 ;
38549 int res1 = 0 ;
38550 int val2 ;
38551 int ecode2 = 0 ;
38552 bool temp3 = false ;
38553 bool temp4 = false ;
38554 PyObject * obj0 = 0 ;
38555 PyObject * obj1 = 0 ;
38556 PyObject * obj2 = 0 ;
38557 PyObject * obj3 = 0 ;
38558 char * kwnames[] = {
38559 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38560 };
38561
38562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38564 if (!SWIG_IsOK(res1)) {
38565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38566 }
38567 arg1 = reinterpret_cast< wxMenu * >(argp1);
38568 ecode2 = SWIG_AsVal_int(obj1, &val2);
38569 if (!SWIG_IsOK(ecode2)) {
38570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38571 }
38572 arg2 = static_cast< int >(val2);
38573 {
38574 arg3 = wxString_in_helper(obj2);
38575 if (arg3 == NULL) SWIG_fail;
38576 temp3 = true;
38577 }
38578 if (obj3) {
38579 {
38580 arg4 = wxString_in_helper(obj3);
38581 if (arg4 == NULL) SWIG_fail;
38582 temp4 = true;
38583 }
38584 }
38585 {
38586 PyThreadState* __tstate = wxPyBeginAllowThreads();
38587 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38588 wxPyEndAllowThreads(__tstate);
38589 if (PyErr_Occurred()) SWIG_fail;
38590 }
38591 {
38592 resultobj = wxPyMake_wxObject(result, (bool)0);
38593 }
38594 {
38595 if (temp3)
38596 delete arg3;
38597 }
38598 {
38599 if (temp4)
38600 delete arg4;
38601 }
38602 return resultobj;
38603 fail:
38604 {
38605 if (temp3)
38606 delete arg3;
38607 }
38608 {
38609 if (temp4)
38610 delete arg4;
38611 }
38612 return NULL;
38613 }
38614
38615
38616 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38617 PyObject *resultobj = 0;
38618 wxMenu *arg1 = (wxMenu *) 0 ;
38619 int arg2 ;
38620 wxString *arg3 = 0 ;
38621 wxMenu *arg4 = (wxMenu *) 0 ;
38622 wxString const &arg5_defvalue = wxPyEmptyString ;
38623 wxString *arg5 = (wxString *) &arg5_defvalue ;
38624 wxMenuItem *result = 0 ;
38625 void *argp1 = 0 ;
38626 int res1 = 0 ;
38627 int val2 ;
38628 int ecode2 = 0 ;
38629 bool temp3 = false ;
38630 void *argp4 = 0 ;
38631 int res4 = 0 ;
38632 bool temp5 = false ;
38633 PyObject * obj0 = 0 ;
38634 PyObject * obj1 = 0 ;
38635 PyObject * obj2 = 0 ;
38636 PyObject * obj3 = 0 ;
38637 PyObject * obj4 = 0 ;
38638 char * kwnames[] = {
38639 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38640 };
38641
38642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38646 }
38647 arg1 = reinterpret_cast< wxMenu * >(argp1);
38648 ecode2 = SWIG_AsVal_int(obj1, &val2);
38649 if (!SWIG_IsOK(ecode2)) {
38650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38651 }
38652 arg2 = static_cast< int >(val2);
38653 {
38654 arg3 = wxString_in_helper(obj2);
38655 if (arg3 == NULL) SWIG_fail;
38656 temp3 = true;
38657 }
38658 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38659 if (!SWIG_IsOK(res4)) {
38660 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38661 }
38662 arg4 = reinterpret_cast< wxMenu * >(argp4);
38663 if (obj4) {
38664 {
38665 arg5 = wxString_in_helper(obj4);
38666 if (arg5 == NULL) SWIG_fail;
38667 temp5 = true;
38668 }
38669 }
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 resultobj = wxPyMake_wxObject(result, (bool)0);
38678 }
38679 {
38680 if (temp3)
38681 delete arg3;
38682 }
38683 {
38684 if (temp5)
38685 delete arg5;
38686 }
38687 return resultobj;
38688 fail:
38689 {
38690 if (temp3)
38691 delete arg3;
38692 }
38693 {
38694 if (temp5)
38695 delete arg5;
38696 }
38697 return NULL;
38698 }
38699
38700
38701 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38702 PyObject *resultobj = 0;
38703 wxMenu *arg1 = (wxMenu *) 0 ;
38704 wxMenu *arg2 = (wxMenu *) 0 ;
38705 wxString *arg3 = 0 ;
38706 wxString const &arg4_defvalue = wxPyEmptyString ;
38707 wxString *arg4 = (wxString *) &arg4_defvalue ;
38708 wxMenuItem *result = 0 ;
38709 void *argp1 = 0 ;
38710 int res1 = 0 ;
38711 void *argp2 = 0 ;
38712 int res2 = 0 ;
38713 bool temp3 = false ;
38714 bool temp4 = false ;
38715 PyObject * obj0 = 0 ;
38716 PyObject * obj1 = 0 ;
38717 PyObject * obj2 = 0 ;
38718 PyObject * obj3 = 0 ;
38719 char * kwnames[] = {
38720 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38721 };
38722
38723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38725 if (!SWIG_IsOK(res1)) {
38726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38727 }
38728 arg1 = reinterpret_cast< wxMenu * >(argp1);
38729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38730 if (!SWIG_IsOK(res2)) {
38731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38732 }
38733 arg2 = reinterpret_cast< wxMenu * >(argp2);
38734 {
38735 arg3 = wxString_in_helper(obj2);
38736 if (arg3 == NULL) SWIG_fail;
38737 temp3 = true;
38738 }
38739 if (obj3) {
38740 {
38741 arg4 = wxString_in_helper(obj3);
38742 if (arg4 == NULL) SWIG_fail;
38743 temp4 = true;
38744 }
38745 }
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 {
38753 resultobj = wxPyMake_wxObject(result, (bool)0);
38754 }
38755 {
38756 if (temp3)
38757 delete arg3;
38758 }
38759 {
38760 if (temp4)
38761 delete arg4;
38762 }
38763 return resultobj;
38764 fail:
38765 {
38766 if (temp3)
38767 delete arg3;
38768 }
38769 {
38770 if (temp4)
38771 delete arg4;
38772 }
38773 return NULL;
38774 }
38775
38776
38777 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38778 PyObject *resultobj = 0;
38779 wxMenu *arg1 = (wxMenu *) 0 ;
38780 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38781 wxMenuItem *result = 0 ;
38782 void *argp1 = 0 ;
38783 int res1 = 0 ;
38784 int res2 = 0 ;
38785 PyObject * obj0 = 0 ;
38786 PyObject * obj1 = 0 ;
38787 char * kwnames[] = {
38788 (char *) "self",(char *) "item", NULL
38789 };
38790
38791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38793 if (!SWIG_IsOK(res1)) {
38794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38795 }
38796 arg1 = reinterpret_cast< wxMenu * >(argp1);
38797 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38798 if (!SWIG_IsOK(res2)) {
38799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38800 }
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 result = (wxMenuItem *)(arg1)->Append(arg2);
38804 wxPyEndAllowThreads(__tstate);
38805 if (PyErr_Occurred()) SWIG_fail;
38806 }
38807 {
38808 resultobj = wxPyMake_wxObject(result, (bool)0);
38809 }
38810 return resultobj;
38811 fail:
38812 return NULL;
38813 }
38814
38815
38816 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38817 PyObject *resultobj = 0;
38818 wxMenu *arg1 = (wxMenu *) 0 ;
38819 size_t arg2 ;
38820 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38821 wxMenuItem *result = 0 ;
38822 void *argp1 = 0 ;
38823 int res1 = 0 ;
38824 size_t val2 ;
38825 int ecode2 = 0 ;
38826 int res3 = 0 ;
38827 PyObject * obj0 = 0 ;
38828 PyObject * obj1 = 0 ;
38829 PyObject * obj2 = 0 ;
38830 char * kwnames[] = {
38831 (char *) "self",(char *) "pos",(char *) "item", NULL
38832 };
38833
38834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38838 }
38839 arg1 = reinterpret_cast< wxMenu * >(argp1);
38840 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38841 if (!SWIG_IsOK(ecode2)) {
38842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38843 }
38844 arg2 = static_cast< size_t >(val2);
38845 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38846 if (!SWIG_IsOK(res3)) {
38847 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38848 }
38849 {
38850 PyThreadState* __tstate = wxPyBeginAllowThreads();
38851 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38852 wxPyEndAllowThreads(__tstate);
38853 if (PyErr_Occurred()) SWIG_fail;
38854 }
38855 {
38856 resultobj = wxPyMake_wxObject(result, (bool)0);
38857 }
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj = 0;
38866 wxMenu *arg1 = (wxMenu *) 0 ;
38867 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38868 wxMenuItem *result = 0 ;
38869 void *argp1 = 0 ;
38870 int res1 = 0 ;
38871 int res2 = 0 ;
38872 PyObject * obj0 = 0 ;
38873 PyObject * obj1 = 0 ;
38874 char * kwnames[] = {
38875 (char *) "self",(char *) "item", NULL
38876 };
38877
38878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38880 if (!SWIG_IsOK(res1)) {
38881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38882 }
38883 arg1 = reinterpret_cast< wxMenu * >(argp1);
38884 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38885 if (!SWIG_IsOK(res2)) {
38886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38887 }
38888 {
38889 PyThreadState* __tstate = wxPyBeginAllowThreads();
38890 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 {
38895 resultobj = wxPyMake_wxObject(result, (bool)0);
38896 }
38897 return resultobj;
38898 fail:
38899 return NULL;
38900 }
38901
38902
38903 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38904 PyObject *resultobj = 0;
38905 wxMenu *arg1 = (wxMenu *) 0 ;
38906 void *argp1 = 0 ;
38907 int res1 = 0 ;
38908 PyObject *swig_obj[1] ;
38909
38910 if (!args) SWIG_fail;
38911 swig_obj[0] = args;
38912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38913 if (!SWIG_IsOK(res1)) {
38914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38915 }
38916 arg1 = reinterpret_cast< wxMenu * >(argp1);
38917 {
38918 PyThreadState* __tstate = wxPyBeginAllowThreads();
38919 (arg1)->Break();
38920 wxPyEndAllowThreads(__tstate);
38921 if (PyErr_Occurred()) SWIG_fail;
38922 }
38923 resultobj = SWIG_Py_Void();
38924 return resultobj;
38925 fail:
38926 return NULL;
38927 }
38928
38929
38930 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38931 PyObject *resultobj = 0;
38932 wxMenu *arg1 = (wxMenu *) 0 ;
38933 size_t arg2 ;
38934 int arg3 ;
38935 wxString *arg4 = 0 ;
38936 wxString const &arg5_defvalue = wxPyEmptyString ;
38937 wxString *arg5 = (wxString *) &arg5_defvalue ;
38938 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38939 wxMenuItem *result = 0 ;
38940 void *argp1 = 0 ;
38941 int res1 = 0 ;
38942 size_t val2 ;
38943 int ecode2 = 0 ;
38944 int val3 ;
38945 int ecode3 = 0 ;
38946 bool temp4 = false ;
38947 bool temp5 = false ;
38948 int val6 ;
38949 int ecode6 = 0 ;
38950 PyObject * obj0 = 0 ;
38951 PyObject * obj1 = 0 ;
38952 PyObject * obj2 = 0 ;
38953 PyObject * obj3 = 0 ;
38954 PyObject * obj4 = 0 ;
38955 PyObject * obj5 = 0 ;
38956 char * kwnames[] = {
38957 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38958 };
38959
38960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38962 if (!SWIG_IsOK(res1)) {
38963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38964 }
38965 arg1 = reinterpret_cast< wxMenu * >(argp1);
38966 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38967 if (!SWIG_IsOK(ecode2)) {
38968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38969 }
38970 arg2 = static_cast< size_t >(val2);
38971 ecode3 = SWIG_AsVal_int(obj2, &val3);
38972 if (!SWIG_IsOK(ecode3)) {
38973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38974 }
38975 arg3 = static_cast< int >(val3);
38976 {
38977 arg4 = wxString_in_helper(obj3);
38978 if (arg4 == NULL) SWIG_fail;
38979 temp4 = true;
38980 }
38981 if (obj4) {
38982 {
38983 arg5 = wxString_in_helper(obj4);
38984 if (arg5 == NULL) SWIG_fail;
38985 temp5 = true;
38986 }
38987 }
38988 if (obj5) {
38989 ecode6 = SWIG_AsVal_int(obj5, &val6);
38990 if (!SWIG_IsOK(ecode6)) {
38991 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38992 }
38993 arg6 = static_cast< wxItemKind >(val6);
38994 }
38995 {
38996 PyThreadState* __tstate = wxPyBeginAllowThreads();
38997 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38998 wxPyEndAllowThreads(__tstate);
38999 if (PyErr_Occurred()) SWIG_fail;
39000 }
39001 {
39002 resultobj = wxPyMake_wxObject(result, (bool)0);
39003 }
39004 {
39005 if (temp4)
39006 delete arg4;
39007 }
39008 {
39009 if (temp5)
39010 delete arg5;
39011 }
39012 return resultobj;
39013 fail:
39014 {
39015 if (temp4)
39016 delete arg4;
39017 }
39018 {
39019 if (temp5)
39020 delete arg5;
39021 }
39022 return NULL;
39023 }
39024
39025
39026 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39027 PyObject *resultobj = 0;
39028 wxMenu *arg1 = (wxMenu *) 0 ;
39029 size_t arg2 ;
39030 wxMenuItem *result = 0 ;
39031 void *argp1 = 0 ;
39032 int res1 = 0 ;
39033 size_t val2 ;
39034 int ecode2 = 0 ;
39035 PyObject * obj0 = 0 ;
39036 PyObject * obj1 = 0 ;
39037 char * kwnames[] = {
39038 (char *) "self",(char *) "pos", NULL
39039 };
39040
39041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39043 if (!SWIG_IsOK(res1)) {
39044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39045 }
39046 arg1 = reinterpret_cast< wxMenu * >(argp1);
39047 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39048 if (!SWIG_IsOK(ecode2)) {
39049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39050 }
39051 arg2 = static_cast< size_t >(val2);
39052 {
39053 PyThreadState* __tstate = wxPyBeginAllowThreads();
39054 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39055 wxPyEndAllowThreads(__tstate);
39056 if (PyErr_Occurred()) SWIG_fail;
39057 }
39058 {
39059 resultobj = wxPyMake_wxObject(result, (bool)0);
39060 }
39061 return resultobj;
39062 fail:
39063 return NULL;
39064 }
39065
39066
39067 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39068 PyObject *resultobj = 0;
39069 wxMenu *arg1 = (wxMenu *) 0 ;
39070 size_t arg2 ;
39071 int arg3 ;
39072 wxString *arg4 = 0 ;
39073 wxString const &arg5_defvalue = wxPyEmptyString ;
39074 wxString *arg5 = (wxString *) &arg5_defvalue ;
39075 wxMenuItem *result = 0 ;
39076 void *argp1 = 0 ;
39077 int res1 = 0 ;
39078 size_t val2 ;
39079 int ecode2 = 0 ;
39080 int val3 ;
39081 int ecode3 = 0 ;
39082 bool temp4 = false ;
39083 bool temp5 = false ;
39084 PyObject * obj0 = 0 ;
39085 PyObject * obj1 = 0 ;
39086 PyObject * obj2 = 0 ;
39087 PyObject * obj3 = 0 ;
39088 PyObject * obj4 = 0 ;
39089 char * kwnames[] = {
39090 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39091 };
39092
39093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39095 if (!SWIG_IsOK(res1)) {
39096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39097 }
39098 arg1 = reinterpret_cast< wxMenu * >(argp1);
39099 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39100 if (!SWIG_IsOK(ecode2)) {
39101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39102 }
39103 arg2 = static_cast< size_t >(val2);
39104 ecode3 = SWIG_AsVal_int(obj2, &val3);
39105 if (!SWIG_IsOK(ecode3)) {
39106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39107 }
39108 arg3 = static_cast< int >(val3);
39109 {
39110 arg4 = wxString_in_helper(obj3);
39111 if (arg4 == NULL) SWIG_fail;
39112 temp4 = true;
39113 }
39114 if (obj4) {
39115 {
39116 arg5 = wxString_in_helper(obj4);
39117 if (arg5 == NULL) SWIG_fail;
39118 temp5 = true;
39119 }
39120 }
39121 {
39122 PyThreadState* __tstate = wxPyBeginAllowThreads();
39123 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 {
39128 resultobj = wxPyMake_wxObject(result, (bool)0);
39129 }
39130 {
39131 if (temp4)
39132 delete arg4;
39133 }
39134 {
39135 if (temp5)
39136 delete arg5;
39137 }
39138 return resultobj;
39139 fail:
39140 {
39141 if (temp4)
39142 delete arg4;
39143 }
39144 {
39145 if (temp5)
39146 delete arg5;
39147 }
39148 return NULL;
39149 }
39150
39151
39152 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39153 PyObject *resultobj = 0;
39154 wxMenu *arg1 = (wxMenu *) 0 ;
39155 size_t arg2 ;
39156 int arg3 ;
39157 wxString *arg4 = 0 ;
39158 wxString const &arg5_defvalue = wxPyEmptyString ;
39159 wxString *arg5 = (wxString *) &arg5_defvalue ;
39160 wxMenuItem *result = 0 ;
39161 void *argp1 = 0 ;
39162 int res1 = 0 ;
39163 size_t val2 ;
39164 int ecode2 = 0 ;
39165 int val3 ;
39166 int ecode3 = 0 ;
39167 bool temp4 = false ;
39168 bool temp5 = false ;
39169 PyObject * obj0 = 0 ;
39170 PyObject * obj1 = 0 ;
39171 PyObject * obj2 = 0 ;
39172 PyObject * obj3 = 0 ;
39173 PyObject * obj4 = 0 ;
39174 char * kwnames[] = {
39175 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39176 };
39177
39178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39180 if (!SWIG_IsOK(res1)) {
39181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39182 }
39183 arg1 = reinterpret_cast< wxMenu * >(argp1);
39184 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39185 if (!SWIG_IsOK(ecode2)) {
39186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39187 }
39188 arg2 = static_cast< size_t >(val2);
39189 ecode3 = SWIG_AsVal_int(obj2, &val3);
39190 if (!SWIG_IsOK(ecode3)) {
39191 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39192 }
39193 arg3 = static_cast< int >(val3);
39194 {
39195 arg4 = wxString_in_helper(obj3);
39196 if (arg4 == NULL) SWIG_fail;
39197 temp4 = true;
39198 }
39199 if (obj4) {
39200 {
39201 arg5 = wxString_in_helper(obj4);
39202 if (arg5 == NULL) SWIG_fail;
39203 temp5 = true;
39204 }
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 {
39213 resultobj = wxPyMake_wxObject(result, (bool)0);
39214 }
39215 {
39216 if (temp4)
39217 delete arg4;
39218 }
39219 {
39220 if (temp5)
39221 delete arg5;
39222 }
39223 return resultobj;
39224 fail:
39225 {
39226 if (temp4)
39227 delete arg4;
39228 }
39229 {
39230 if (temp5)
39231 delete arg5;
39232 }
39233 return NULL;
39234 }
39235
39236
39237 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj = 0;
39239 wxMenu *arg1 = (wxMenu *) 0 ;
39240 size_t arg2 ;
39241 int arg3 ;
39242 wxString *arg4 = 0 ;
39243 wxMenu *arg5 = (wxMenu *) 0 ;
39244 wxString const &arg6_defvalue = wxPyEmptyString ;
39245 wxString *arg6 = (wxString *) &arg6_defvalue ;
39246 wxMenuItem *result = 0 ;
39247 void *argp1 = 0 ;
39248 int res1 = 0 ;
39249 size_t val2 ;
39250 int ecode2 = 0 ;
39251 int val3 ;
39252 int ecode3 = 0 ;
39253 bool temp4 = false ;
39254 void *argp5 = 0 ;
39255 int res5 = 0 ;
39256 bool temp6 = false ;
39257 PyObject * obj0 = 0 ;
39258 PyObject * obj1 = 0 ;
39259 PyObject * obj2 = 0 ;
39260 PyObject * obj3 = 0 ;
39261 PyObject * obj4 = 0 ;
39262 PyObject * obj5 = 0 ;
39263 char * kwnames[] = {
39264 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39265 };
39266
39267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39269 if (!SWIG_IsOK(res1)) {
39270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39271 }
39272 arg1 = reinterpret_cast< wxMenu * >(argp1);
39273 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39274 if (!SWIG_IsOK(ecode2)) {
39275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39276 }
39277 arg2 = static_cast< size_t >(val2);
39278 ecode3 = SWIG_AsVal_int(obj2, &val3);
39279 if (!SWIG_IsOK(ecode3)) {
39280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39281 }
39282 arg3 = static_cast< int >(val3);
39283 {
39284 arg4 = wxString_in_helper(obj3);
39285 if (arg4 == NULL) SWIG_fail;
39286 temp4 = true;
39287 }
39288 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39289 if (!SWIG_IsOK(res5)) {
39290 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39291 }
39292 arg5 = reinterpret_cast< wxMenu * >(argp5);
39293 if (obj5) {
39294 {
39295 arg6 = wxString_in_helper(obj5);
39296 if (arg6 == NULL) SWIG_fail;
39297 temp6 = true;
39298 }
39299 }
39300 {
39301 PyThreadState* __tstate = wxPyBeginAllowThreads();
39302 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39303 wxPyEndAllowThreads(__tstate);
39304 if (PyErr_Occurred()) SWIG_fail;
39305 }
39306 {
39307 resultobj = wxPyMake_wxObject(result, (bool)0);
39308 }
39309 {
39310 if (temp4)
39311 delete arg4;
39312 }
39313 {
39314 if (temp6)
39315 delete arg6;
39316 }
39317 return resultobj;
39318 fail:
39319 {
39320 if (temp4)
39321 delete arg4;
39322 }
39323 {
39324 if (temp6)
39325 delete arg6;
39326 }
39327 return NULL;
39328 }
39329
39330
39331 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39332 PyObject *resultobj = 0;
39333 wxMenu *arg1 = (wxMenu *) 0 ;
39334 int arg2 ;
39335 wxString *arg3 = 0 ;
39336 wxString const &arg4_defvalue = wxPyEmptyString ;
39337 wxString *arg4 = (wxString *) &arg4_defvalue ;
39338 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39339 wxMenuItem *result = 0 ;
39340 void *argp1 = 0 ;
39341 int res1 = 0 ;
39342 int val2 ;
39343 int ecode2 = 0 ;
39344 bool temp3 = false ;
39345 bool temp4 = false ;
39346 int val5 ;
39347 int ecode5 = 0 ;
39348 PyObject * obj0 = 0 ;
39349 PyObject * obj1 = 0 ;
39350 PyObject * obj2 = 0 ;
39351 PyObject * obj3 = 0 ;
39352 PyObject * obj4 = 0 ;
39353 char * kwnames[] = {
39354 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39355 };
39356
39357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39359 if (!SWIG_IsOK(res1)) {
39360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39361 }
39362 arg1 = reinterpret_cast< wxMenu * >(argp1);
39363 ecode2 = SWIG_AsVal_int(obj1, &val2);
39364 if (!SWIG_IsOK(ecode2)) {
39365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39366 }
39367 arg2 = static_cast< int >(val2);
39368 {
39369 arg3 = wxString_in_helper(obj2);
39370 if (arg3 == NULL) SWIG_fail;
39371 temp3 = true;
39372 }
39373 if (obj3) {
39374 {
39375 arg4 = wxString_in_helper(obj3);
39376 if (arg4 == NULL) SWIG_fail;
39377 temp4 = true;
39378 }
39379 }
39380 if (obj4) {
39381 ecode5 = SWIG_AsVal_int(obj4, &val5);
39382 if (!SWIG_IsOK(ecode5)) {
39383 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39384 }
39385 arg5 = static_cast< wxItemKind >(val5);
39386 }
39387 {
39388 PyThreadState* __tstate = wxPyBeginAllowThreads();
39389 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39390 wxPyEndAllowThreads(__tstate);
39391 if (PyErr_Occurred()) SWIG_fail;
39392 }
39393 {
39394 resultobj = wxPyMake_wxObject(result, (bool)0);
39395 }
39396 {
39397 if (temp3)
39398 delete arg3;
39399 }
39400 {
39401 if (temp4)
39402 delete arg4;
39403 }
39404 return resultobj;
39405 fail:
39406 {
39407 if (temp3)
39408 delete arg3;
39409 }
39410 {
39411 if (temp4)
39412 delete arg4;
39413 }
39414 return NULL;
39415 }
39416
39417
39418 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39419 PyObject *resultobj = 0;
39420 wxMenu *arg1 = (wxMenu *) 0 ;
39421 wxMenuItem *result = 0 ;
39422 void *argp1 = 0 ;
39423 int res1 = 0 ;
39424 PyObject *swig_obj[1] ;
39425
39426 if (!args) SWIG_fail;
39427 swig_obj[0] = args;
39428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39429 if (!SWIG_IsOK(res1)) {
39430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39431 }
39432 arg1 = reinterpret_cast< wxMenu * >(argp1);
39433 {
39434 PyThreadState* __tstate = wxPyBeginAllowThreads();
39435 result = (wxMenuItem *)(arg1)->PrependSeparator();
39436 wxPyEndAllowThreads(__tstate);
39437 if (PyErr_Occurred()) SWIG_fail;
39438 }
39439 {
39440 resultobj = wxPyMake_wxObject(result, (bool)0);
39441 }
39442 return resultobj;
39443 fail:
39444 return NULL;
39445 }
39446
39447
39448 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39449 PyObject *resultobj = 0;
39450 wxMenu *arg1 = (wxMenu *) 0 ;
39451 int arg2 ;
39452 wxString *arg3 = 0 ;
39453 wxString const &arg4_defvalue = wxPyEmptyString ;
39454 wxString *arg4 = (wxString *) &arg4_defvalue ;
39455 wxMenuItem *result = 0 ;
39456 void *argp1 = 0 ;
39457 int res1 = 0 ;
39458 int val2 ;
39459 int ecode2 = 0 ;
39460 bool temp3 = false ;
39461 bool temp4 = false ;
39462 PyObject * obj0 = 0 ;
39463 PyObject * obj1 = 0 ;
39464 PyObject * obj2 = 0 ;
39465 PyObject * obj3 = 0 ;
39466 char * kwnames[] = {
39467 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39468 };
39469
39470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39472 if (!SWIG_IsOK(res1)) {
39473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39474 }
39475 arg1 = reinterpret_cast< wxMenu * >(argp1);
39476 ecode2 = SWIG_AsVal_int(obj1, &val2);
39477 if (!SWIG_IsOK(ecode2)) {
39478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39479 }
39480 arg2 = static_cast< int >(val2);
39481 {
39482 arg3 = wxString_in_helper(obj2);
39483 if (arg3 == NULL) SWIG_fail;
39484 temp3 = true;
39485 }
39486 if (obj3) {
39487 {
39488 arg4 = wxString_in_helper(obj3);
39489 if (arg4 == NULL) SWIG_fail;
39490 temp4 = true;
39491 }
39492 }
39493 {
39494 PyThreadState* __tstate = wxPyBeginAllowThreads();
39495 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39496 wxPyEndAllowThreads(__tstate);
39497 if (PyErr_Occurred()) SWIG_fail;
39498 }
39499 {
39500 resultobj = wxPyMake_wxObject(result, (bool)0);
39501 }
39502 {
39503 if (temp3)
39504 delete arg3;
39505 }
39506 {
39507 if (temp4)
39508 delete arg4;
39509 }
39510 return resultobj;
39511 fail:
39512 {
39513 if (temp3)
39514 delete arg3;
39515 }
39516 {
39517 if (temp4)
39518 delete arg4;
39519 }
39520 return NULL;
39521 }
39522
39523
39524 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj = 0;
39526 wxMenu *arg1 = (wxMenu *) 0 ;
39527 int arg2 ;
39528 wxString *arg3 = 0 ;
39529 wxString const &arg4_defvalue = wxPyEmptyString ;
39530 wxString *arg4 = (wxString *) &arg4_defvalue ;
39531 wxMenuItem *result = 0 ;
39532 void *argp1 = 0 ;
39533 int res1 = 0 ;
39534 int val2 ;
39535 int ecode2 = 0 ;
39536 bool temp3 = false ;
39537 bool temp4 = false ;
39538 PyObject * obj0 = 0 ;
39539 PyObject * obj1 = 0 ;
39540 PyObject * obj2 = 0 ;
39541 PyObject * obj3 = 0 ;
39542 char * kwnames[] = {
39543 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39544 };
39545
39546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39548 if (!SWIG_IsOK(res1)) {
39549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39550 }
39551 arg1 = reinterpret_cast< wxMenu * >(argp1);
39552 ecode2 = SWIG_AsVal_int(obj1, &val2);
39553 if (!SWIG_IsOK(ecode2)) {
39554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39555 }
39556 arg2 = static_cast< int >(val2);
39557 {
39558 arg3 = wxString_in_helper(obj2);
39559 if (arg3 == NULL) SWIG_fail;
39560 temp3 = true;
39561 }
39562 if (obj3) {
39563 {
39564 arg4 = wxString_in_helper(obj3);
39565 if (arg4 == NULL) SWIG_fail;
39566 temp4 = true;
39567 }
39568 }
39569 {
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39572 wxPyEndAllowThreads(__tstate);
39573 if (PyErr_Occurred()) SWIG_fail;
39574 }
39575 {
39576 resultobj = wxPyMake_wxObject(result, (bool)0);
39577 }
39578 {
39579 if (temp3)
39580 delete arg3;
39581 }
39582 {
39583 if (temp4)
39584 delete arg4;
39585 }
39586 return resultobj;
39587 fail:
39588 {
39589 if (temp3)
39590 delete arg3;
39591 }
39592 {
39593 if (temp4)
39594 delete arg4;
39595 }
39596 return NULL;
39597 }
39598
39599
39600 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39601 PyObject *resultobj = 0;
39602 wxMenu *arg1 = (wxMenu *) 0 ;
39603 int arg2 ;
39604 wxString *arg3 = 0 ;
39605 wxMenu *arg4 = (wxMenu *) 0 ;
39606 wxString const &arg5_defvalue = wxPyEmptyString ;
39607 wxString *arg5 = (wxString *) &arg5_defvalue ;
39608 wxMenuItem *result = 0 ;
39609 void *argp1 = 0 ;
39610 int res1 = 0 ;
39611 int val2 ;
39612 int ecode2 = 0 ;
39613 bool temp3 = false ;
39614 void *argp4 = 0 ;
39615 int res4 = 0 ;
39616 bool temp5 = false ;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 PyObject * obj2 = 0 ;
39620 PyObject * obj3 = 0 ;
39621 PyObject * obj4 = 0 ;
39622 char * kwnames[] = {
39623 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39624 };
39625
39626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39630 }
39631 arg1 = reinterpret_cast< wxMenu * >(argp1);
39632 ecode2 = SWIG_AsVal_int(obj1, &val2);
39633 if (!SWIG_IsOK(ecode2)) {
39634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39635 }
39636 arg2 = static_cast< int >(val2);
39637 {
39638 arg3 = wxString_in_helper(obj2);
39639 if (arg3 == NULL) SWIG_fail;
39640 temp3 = true;
39641 }
39642 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39643 if (!SWIG_IsOK(res4)) {
39644 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39645 }
39646 arg4 = reinterpret_cast< wxMenu * >(argp4);
39647 if (obj4) {
39648 {
39649 arg5 = wxString_in_helper(obj4);
39650 if (arg5 == NULL) SWIG_fail;
39651 temp5 = true;
39652 }
39653 }
39654 {
39655 PyThreadState* __tstate = wxPyBeginAllowThreads();
39656 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39657 wxPyEndAllowThreads(__tstate);
39658 if (PyErr_Occurred()) SWIG_fail;
39659 }
39660 {
39661 resultobj = wxPyMake_wxObject(result, (bool)0);
39662 }
39663 {
39664 if (temp3)
39665 delete arg3;
39666 }
39667 {
39668 if (temp5)
39669 delete arg5;
39670 }
39671 return resultobj;
39672 fail:
39673 {
39674 if (temp3)
39675 delete arg3;
39676 }
39677 {
39678 if (temp5)
39679 delete arg5;
39680 }
39681 return NULL;
39682 }
39683
39684
39685 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39686 PyObject *resultobj = 0;
39687 wxMenu *arg1 = (wxMenu *) 0 ;
39688 int arg2 ;
39689 wxMenuItem *result = 0 ;
39690 void *argp1 = 0 ;
39691 int res1 = 0 ;
39692 int val2 ;
39693 int ecode2 = 0 ;
39694 PyObject * obj0 = 0 ;
39695 PyObject * obj1 = 0 ;
39696 char * kwnames[] = {
39697 (char *) "self",(char *) "id", NULL
39698 };
39699
39700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39702 if (!SWIG_IsOK(res1)) {
39703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39704 }
39705 arg1 = reinterpret_cast< wxMenu * >(argp1);
39706 ecode2 = SWIG_AsVal_int(obj1, &val2);
39707 if (!SWIG_IsOK(ecode2)) {
39708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39709 }
39710 arg2 = static_cast< int >(val2);
39711 {
39712 PyThreadState* __tstate = wxPyBeginAllowThreads();
39713 result = (wxMenuItem *)(arg1)->Remove(arg2);
39714 wxPyEndAllowThreads(__tstate);
39715 if (PyErr_Occurred()) SWIG_fail;
39716 }
39717 {
39718 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39719 }
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39727 PyObject *resultobj = 0;
39728 wxMenu *arg1 = (wxMenu *) 0 ;
39729 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39730 wxMenuItem *result = 0 ;
39731 void *argp1 = 0 ;
39732 int res1 = 0 ;
39733 void *argp2 = 0 ;
39734 int res2 = 0 ;
39735 PyObject * obj0 = 0 ;
39736 PyObject * obj1 = 0 ;
39737 char * kwnames[] = {
39738 (char *) "self",(char *) "item", NULL
39739 };
39740
39741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39743 if (!SWIG_IsOK(res1)) {
39744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39745 }
39746 arg1 = reinterpret_cast< wxMenu * >(argp1);
39747 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39748 if (!SWIG_IsOK(res2)) {
39749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39750 }
39751 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 result = (wxMenuItem *)(arg1)->Remove(arg2);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 {
39759 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39760 }
39761 return resultobj;
39762 fail:
39763 return NULL;
39764 }
39765
39766
39767 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39768 PyObject *resultobj = 0;
39769 wxMenu *arg1 = (wxMenu *) 0 ;
39770 int arg2 ;
39771 bool result;
39772 void *argp1 = 0 ;
39773 int res1 = 0 ;
39774 int val2 ;
39775 int ecode2 = 0 ;
39776 PyObject * obj0 = 0 ;
39777 PyObject * obj1 = 0 ;
39778 char * kwnames[] = {
39779 (char *) "self",(char *) "id", NULL
39780 };
39781
39782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39784 if (!SWIG_IsOK(res1)) {
39785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39786 }
39787 arg1 = reinterpret_cast< wxMenu * >(argp1);
39788 ecode2 = SWIG_AsVal_int(obj1, &val2);
39789 if (!SWIG_IsOK(ecode2)) {
39790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39791 }
39792 arg2 = static_cast< int >(val2);
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 result = (bool)(arg1)->Delete(arg2);
39796 wxPyEndAllowThreads(__tstate);
39797 if (PyErr_Occurred()) SWIG_fail;
39798 }
39799 {
39800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39801 }
39802 return resultobj;
39803 fail:
39804 return NULL;
39805 }
39806
39807
39808 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39809 PyObject *resultobj = 0;
39810 wxMenu *arg1 = (wxMenu *) 0 ;
39811 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39812 bool result;
39813 void *argp1 = 0 ;
39814 int res1 = 0 ;
39815 void *argp2 = 0 ;
39816 int res2 = 0 ;
39817 PyObject * obj0 = 0 ;
39818 PyObject * obj1 = 0 ;
39819 char * kwnames[] = {
39820 (char *) "self",(char *) "item", NULL
39821 };
39822
39823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39825 if (!SWIG_IsOK(res1)) {
39826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39827 }
39828 arg1 = reinterpret_cast< wxMenu * >(argp1);
39829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39830 if (!SWIG_IsOK(res2)) {
39831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39832 }
39833 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39834 {
39835 PyThreadState* __tstate = wxPyBeginAllowThreads();
39836 result = (bool)(arg1)->Delete(arg2);
39837 wxPyEndAllowThreads(__tstate);
39838 if (PyErr_Occurred()) SWIG_fail;
39839 }
39840 {
39841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39842 }
39843 return resultobj;
39844 fail:
39845 return NULL;
39846 }
39847
39848
39849 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39850 PyObject *resultobj = 0;
39851 wxMenu *arg1 = (wxMenu *) 0 ;
39852 void *argp1 = 0 ;
39853 int res1 = 0 ;
39854 PyObject *swig_obj[1] ;
39855
39856 if (!args) SWIG_fail;
39857 swig_obj[0] = args;
39858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39859 if (!SWIG_IsOK(res1)) {
39860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39861 }
39862 arg1 = reinterpret_cast< wxMenu * >(argp1);
39863 {
39864 PyThreadState* __tstate = wxPyBeginAllowThreads();
39865 wxMenu_Destroy(arg1);
39866 wxPyEndAllowThreads(__tstate);
39867 if (PyErr_Occurred()) SWIG_fail;
39868 }
39869 resultobj = SWIG_Py_Void();
39870 return resultobj;
39871 fail:
39872 return NULL;
39873 }
39874
39875
39876 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39877 PyObject *resultobj = 0;
39878 wxMenu *arg1 = (wxMenu *) 0 ;
39879 int arg2 ;
39880 bool result;
39881 void *argp1 = 0 ;
39882 int res1 = 0 ;
39883 int val2 ;
39884 int ecode2 = 0 ;
39885 PyObject * obj0 = 0 ;
39886 PyObject * obj1 = 0 ;
39887 char * kwnames[] = {
39888 (char *) "self",(char *) "id", NULL
39889 };
39890
39891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39893 if (!SWIG_IsOK(res1)) {
39894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39895 }
39896 arg1 = reinterpret_cast< wxMenu * >(argp1);
39897 ecode2 = SWIG_AsVal_int(obj1, &val2);
39898 if (!SWIG_IsOK(ecode2)) {
39899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39900 }
39901 arg2 = static_cast< int >(val2);
39902 {
39903 PyThreadState* __tstate = wxPyBeginAllowThreads();
39904 result = (bool)(arg1)->Destroy(arg2);
39905 wxPyEndAllowThreads(__tstate);
39906 if (PyErr_Occurred()) SWIG_fail;
39907 }
39908 {
39909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39910 }
39911 return resultobj;
39912 fail:
39913 return NULL;
39914 }
39915
39916
39917 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39918 PyObject *resultobj = 0;
39919 wxMenu *arg1 = (wxMenu *) 0 ;
39920 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39921 bool result;
39922 void *argp1 = 0 ;
39923 int res1 = 0 ;
39924 void *argp2 = 0 ;
39925 int res2 = 0 ;
39926 PyObject * obj0 = 0 ;
39927 PyObject * obj1 = 0 ;
39928 char * kwnames[] = {
39929 (char *) "self",(char *) "item", NULL
39930 };
39931
39932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res1)) {
39935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39936 }
39937 arg1 = reinterpret_cast< wxMenu * >(argp1);
39938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39939 if (!SWIG_IsOK(res2)) {
39940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39941 }
39942 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39943 {
39944 PyThreadState* __tstate = wxPyBeginAllowThreads();
39945 result = (bool)(arg1)->Destroy(arg2);
39946 wxPyEndAllowThreads(__tstate);
39947 if (PyErr_Occurred()) SWIG_fail;
39948 }
39949 {
39950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39951 }
39952 return resultobj;
39953 fail:
39954 return NULL;
39955 }
39956
39957
39958 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39959 PyObject *resultobj = 0;
39960 wxMenu *arg1 = (wxMenu *) 0 ;
39961 size_t result;
39962 void *argp1 = 0 ;
39963 int res1 = 0 ;
39964 PyObject *swig_obj[1] ;
39965
39966 if (!args) SWIG_fail;
39967 swig_obj[0] = args;
39968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39969 if (!SWIG_IsOK(res1)) {
39970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39971 }
39972 arg1 = reinterpret_cast< wxMenu * >(argp1);
39973 {
39974 PyThreadState* __tstate = wxPyBeginAllowThreads();
39975 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39976 wxPyEndAllowThreads(__tstate);
39977 if (PyErr_Occurred()) SWIG_fail;
39978 }
39979 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39980 return resultobj;
39981 fail:
39982 return NULL;
39983 }
39984
39985
39986 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39987 PyObject *resultobj = 0;
39988 wxMenu *arg1 = (wxMenu *) 0 ;
39989 PyObject *result = 0 ;
39990 void *argp1 = 0 ;
39991 int res1 = 0 ;
39992 PyObject *swig_obj[1] ;
39993
39994 if (!args) SWIG_fail;
39995 swig_obj[0] = args;
39996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39997 if (!SWIG_IsOK(res1)) {
39998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39999 }
40000 arg1 = reinterpret_cast< wxMenu * >(argp1);
40001 {
40002 PyThreadState* __tstate = wxPyBeginAllowThreads();
40003 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40004 wxPyEndAllowThreads(__tstate);
40005 if (PyErr_Occurred()) SWIG_fail;
40006 }
40007 resultobj = result;
40008 return resultobj;
40009 fail:
40010 return NULL;
40011 }
40012
40013
40014 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40015 PyObject *resultobj = 0;
40016 wxMenu *arg1 = (wxMenu *) 0 ;
40017 wxString *arg2 = 0 ;
40018 int result;
40019 void *argp1 = 0 ;
40020 int res1 = 0 ;
40021 bool temp2 = false ;
40022 PyObject * obj0 = 0 ;
40023 PyObject * obj1 = 0 ;
40024 char * kwnames[] = {
40025 (char *) "self",(char *) "item", NULL
40026 };
40027
40028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40030 if (!SWIG_IsOK(res1)) {
40031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40032 }
40033 arg1 = reinterpret_cast< wxMenu * >(argp1);
40034 {
40035 arg2 = wxString_in_helper(obj1);
40036 if (arg2 == NULL) SWIG_fail;
40037 temp2 = true;
40038 }
40039 {
40040 PyThreadState* __tstate = wxPyBeginAllowThreads();
40041 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40042 wxPyEndAllowThreads(__tstate);
40043 if (PyErr_Occurred()) SWIG_fail;
40044 }
40045 resultobj = SWIG_From_int(static_cast< int >(result));
40046 {
40047 if (temp2)
40048 delete arg2;
40049 }
40050 return resultobj;
40051 fail:
40052 {
40053 if (temp2)
40054 delete arg2;
40055 }
40056 return NULL;
40057 }
40058
40059
40060 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40061 PyObject *resultobj = 0;
40062 wxMenu *arg1 = (wxMenu *) 0 ;
40063 int arg2 ;
40064 wxMenuItem *result = 0 ;
40065 void *argp1 = 0 ;
40066 int res1 = 0 ;
40067 int val2 ;
40068 int ecode2 = 0 ;
40069 PyObject * obj0 = 0 ;
40070 PyObject * obj1 = 0 ;
40071 char * kwnames[] = {
40072 (char *) "self",(char *) "id", NULL
40073 };
40074
40075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40077 if (!SWIG_IsOK(res1)) {
40078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40079 }
40080 arg1 = reinterpret_cast< wxMenu * >(argp1);
40081 ecode2 = SWIG_AsVal_int(obj1, &val2);
40082 if (!SWIG_IsOK(ecode2)) {
40083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40084 }
40085 arg2 = static_cast< int >(val2);
40086 {
40087 PyThreadState* __tstate = wxPyBeginAllowThreads();
40088 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 {
40093 resultobj = wxPyMake_wxObject(result, (bool)0);
40094 }
40095 return resultobj;
40096 fail:
40097 return NULL;
40098 }
40099
40100
40101 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40102 PyObject *resultobj = 0;
40103 wxMenu *arg1 = (wxMenu *) 0 ;
40104 size_t arg2 ;
40105 wxMenuItem *result = 0 ;
40106 void *argp1 = 0 ;
40107 int res1 = 0 ;
40108 size_t val2 ;
40109 int ecode2 = 0 ;
40110 PyObject * obj0 = 0 ;
40111 PyObject * obj1 = 0 ;
40112 char * kwnames[] = {
40113 (char *) "self",(char *) "position", NULL
40114 };
40115
40116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40118 if (!SWIG_IsOK(res1)) {
40119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40120 }
40121 arg1 = reinterpret_cast< wxMenu * >(argp1);
40122 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40123 if (!SWIG_IsOK(ecode2)) {
40124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40125 }
40126 arg2 = static_cast< size_t >(val2);
40127 {
40128 PyThreadState* __tstate = wxPyBeginAllowThreads();
40129 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40130 wxPyEndAllowThreads(__tstate);
40131 if (PyErr_Occurred()) SWIG_fail;
40132 }
40133 {
40134 resultobj = wxPyMake_wxObject(result, (bool)0);
40135 }
40136 return resultobj;
40137 fail:
40138 return NULL;
40139 }
40140
40141
40142 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40143 PyObject *resultobj = 0;
40144 wxMenu *arg1 = (wxMenu *) 0 ;
40145 int arg2 ;
40146 bool arg3 ;
40147 void *argp1 = 0 ;
40148 int res1 = 0 ;
40149 int val2 ;
40150 int ecode2 = 0 ;
40151 bool val3 ;
40152 int ecode3 = 0 ;
40153 PyObject * obj0 = 0 ;
40154 PyObject * obj1 = 0 ;
40155 PyObject * obj2 = 0 ;
40156 char * kwnames[] = {
40157 (char *) "self",(char *) "id",(char *) "enable", NULL
40158 };
40159
40160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40162 if (!SWIG_IsOK(res1)) {
40163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40164 }
40165 arg1 = reinterpret_cast< wxMenu * >(argp1);
40166 ecode2 = SWIG_AsVal_int(obj1, &val2);
40167 if (!SWIG_IsOK(ecode2)) {
40168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40169 }
40170 arg2 = static_cast< int >(val2);
40171 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40172 if (!SWIG_IsOK(ecode3)) {
40173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40174 }
40175 arg3 = static_cast< bool >(val3);
40176 {
40177 PyThreadState* __tstate = wxPyBeginAllowThreads();
40178 (arg1)->Enable(arg2,arg3);
40179 wxPyEndAllowThreads(__tstate);
40180 if (PyErr_Occurred()) SWIG_fail;
40181 }
40182 resultobj = SWIG_Py_Void();
40183 return resultobj;
40184 fail:
40185 return NULL;
40186 }
40187
40188
40189 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40190 PyObject *resultobj = 0;
40191 wxMenu *arg1 = (wxMenu *) 0 ;
40192 int arg2 ;
40193 bool result;
40194 void *argp1 = 0 ;
40195 int res1 = 0 ;
40196 int val2 ;
40197 int ecode2 = 0 ;
40198 PyObject * obj0 = 0 ;
40199 PyObject * obj1 = 0 ;
40200 char * kwnames[] = {
40201 (char *) "self",(char *) "id", NULL
40202 };
40203
40204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40206 if (!SWIG_IsOK(res1)) {
40207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40208 }
40209 arg1 = reinterpret_cast< wxMenu * >(argp1);
40210 ecode2 = SWIG_AsVal_int(obj1, &val2);
40211 if (!SWIG_IsOK(ecode2)) {
40212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40213 }
40214 arg2 = static_cast< int >(val2);
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 {
40222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40223 }
40224 return resultobj;
40225 fail:
40226 return NULL;
40227 }
40228
40229
40230 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40231 PyObject *resultobj = 0;
40232 wxMenu *arg1 = (wxMenu *) 0 ;
40233 int arg2 ;
40234 bool arg3 ;
40235 void *argp1 = 0 ;
40236 int res1 = 0 ;
40237 int val2 ;
40238 int ecode2 = 0 ;
40239 bool val3 ;
40240 int ecode3 = 0 ;
40241 PyObject * obj0 = 0 ;
40242 PyObject * obj1 = 0 ;
40243 PyObject * obj2 = 0 ;
40244 char * kwnames[] = {
40245 (char *) "self",(char *) "id",(char *) "check", NULL
40246 };
40247
40248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40250 if (!SWIG_IsOK(res1)) {
40251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40252 }
40253 arg1 = reinterpret_cast< wxMenu * >(argp1);
40254 ecode2 = SWIG_AsVal_int(obj1, &val2);
40255 if (!SWIG_IsOK(ecode2)) {
40256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40257 }
40258 arg2 = static_cast< int >(val2);
40259 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40260 if (!SWIG_IsOK(ecode3)) {
40261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40262 }
40263 arg3 = static_cast< bool >(val3);
40264 {
40265 PyThreadState* __tstate = wxPyBeginAllowThreads();
40266 (arg1)->Check(arg2,arg3);
40267 wxPyEndAllowThreads(__tstate);
40268 if (PyErr_Occurred()) SWIG_fail;
40269 }
40270 resultobj = SWIG_Py_Void();
40271 return resultobj;
40272 fail:
40273 return NULL;
40274 }
40275
40276
40277 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40278 PyObject *resultobj = 0;
40279 wxMenu *arg1 = (wxMenu *) 0 ;
40280 int arg2 ;
40281 bool result;
40282 void *argp1 = 0 ;
40283 int res1 = 0 ;
40284 int val2 ;
40285 int ecode2 = 0 ;
40286 PyObject * obj0 = 0 ;
40287 PyObject * obj1 = 0 ;
40288 char * kwnames[] = {
40289 (char *) "self",(char *) "id", NULL
40290 };
40291
40292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40294 if (!SWIG_IsOK(res1)) {
40295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40296 }
40297 arg1 = reinterpret_cast< wxMenu * >(argp1);
40298 ecode2 = SWIG_AsVal_int(obj1, &val2);
40299 if (!SWIG_IsOK(ecode2)) {
40300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40301 }
40302 arg2 = static_cast< int >(val2);
40303 {
40304 PyThreadState* __tstate = wxPyBeginAllowThreads();
40305 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 {
40310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40311 }
40312 return resultobj;
40313 fail:
40314 return NULL;
40315 }
40316
40317
40318 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj = 0;
40320 wxMenu *arg1 = (wxMenu *) 0 ;
40321 int arg2 ;
40322 wxString *arg3 = 0 ;
40323 void *argp1 = 0 ;
40324 int res1 = 0 ;
40325 int val2 ;
40326 int ecode2 = 0 ;
40327 bool temp3 = false ;
40328 PyObject * obj0 = 0 ;
40329 PyObject * obj1 = 0 ;
40330 PyObject * obj2 = 0 ;
40331 char * kwnames[] = {
40332 (char *) "self",(char *) "id",(char *) "label", NULL
40333 };
40334
40335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40337 if (!SWIG_IsOK(res1)) {
40338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40339 }
40340 arg1 = reinterpret_cast< wxMenu * >(argp1);
40341 ecode2 = SWIG_AsVal_int(obj1, &val2);
40342 if (!SWIG_IsOK(ecode2)) {
40343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40344 }
40345 arg2 = static_cast< int >(val2);
40346 {
40347 arg3 = wxString_in_helper(obj2);
40348 if (arg3 == NULL) SWIG_fail;
40349 temp3 = true;
40350 }
40351 {
40352 PyThreadState* __tstate = wxPyBeginAllowThreads();
40353 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40354 wxPyEndAllowThreads(__tstate);
40355 if (PyErr_Occurred()) SWIG_fail;
40356 }
40357 resultobj = SWIG_Py_Void();
40358 {
40359 if (temp3)
40360 delete arg3;
40361 }
40362 return resultobj;
40363 fail:
40364 {
40365 if (temp3)
40366 delete arg3;
40367 }
40368 return NULL;
40369 }
40370
40371
40372 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40373 PyObject *resultobj = 0;
40374 wxMenu *arg1 = (wxMenu *) 0 ;
40375 int arg2 ;
40376 wxString result;
40377 void *argp1 = 0 ;
40378 int res1 = 0 ;
40379 int val2 ;
40380 int ecode2 = 0 ;
40381 PyObject * obj0 = 0 ;
40382 PyObject * obj1 = 0 ;
40383 char * kwnames[] = {
40384 (char *) "self",(char *) "id", NULL
40385 };
40386
40387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40389 if (!SWIG_IsOK(res1)) {
40390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40391 }
40392 arg1 = reinterpret_cast< wxMenu * >(argp1);
40393 ecode2 = SWIG_AsVal_int(obj1, &val2);
40394 if (!SWIG_IsOK(ecode2)) {
40395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40396 }
40397 arg2 = static_cast< int >(val2);
40398 {
40399 PyThreadState* __tstate = wxPyBeginAllowThreads();
40400 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40401 wxPyEndAllowThreads(__tstate);
40402 if (PyErr_Occurred()) SWIG_fail;
40403 }
40404 {
40405 #if wxUSE_UNICODE
40406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40407 #else
40408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40409 #endif
40410 }
40411 return resultobj;
40412 fail:
40413 return NULL;
40414 }
40415
40416
40417 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40418 PyObject *resultobj = 0;
40419 wxMenu *arg1 = (wxMenu *) 0 ;
40420 int arg2 ;
40421 wxString *arg3 = 0 ;
40422 void *argp1 = 0 ;
40423 int res1 = 0 ;
40424 int val2 ;
40425 int ecode2 = 0 ;
40426 bool temp3 = false ;
40427 PyObject * obj0 = 0 ;
40428 PyObject * obj1 = 0 ;
40429 PyObject * obj2 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "id",(char *) "helpString", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40438 }
40439 arg1 = reinterpret_cast< wxMenu * >(argp1);
40440 ecode2 = SWIG_AsVal_int(obj1, &val2);
40441 if (!SWIG_IsOK(ecode2)) {
40442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40443 }
40444 arg2 = static_cast< int >(val2);
40445 {
40446 arg3 = wxString_in_helper(obj2);
40447 if (arg3 == NULL) SWIG_fail;
40448 temp3 = true;
40449 }
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_Py_Void();
40457 {
40458 if (temp3)
40459 delete arg3;
40460 }
40461 return resultobj;
40462 fail:
40463 {
40464 if (temp3)
40465 delete arg3;
40466 }
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 int arg2 ;
40475 wxString result;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 int val2 ;
40479 int ecode2 = 0 ;
40480 PyObject * obj0 = 0 ;
40481 PyObject * obj1 = 0 ;
40482 char * kwnames[] = {
40483 (char *) "self",(char *) "id", NULL
40484 };
40485
40486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40490 }
40491 arg1 = reinterpret_cast< wxMenu * >(argp1);
40492 ecode2 = SWIG_AsVal_int(obj1, &val2);
40493 if (!SWIG_IsOK(ecode2)) {
40494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40495 }
40496 arg2 = static_cast< int >(val2);
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40500 wxPyEndAllowThreads(__tstate);
40501 if (PyErr_Occurred()) SWIG_fail;
40502 }
40503 {
40504 #if wxUSE_UNICODE
40505 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40506 #else
40507 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40508 #endif
40509 }
40510 return resultobj;
40511 fail:
40512 return NULL;
40513 }
40514
40515
40516 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40517 PyObject *resultobj = 0;
40518 wxMenu *arg1 = (wxMenu *) 0 ;
40519 wxString *arg2 = 0 ;
40520 void *argp1 = 0 ;
40521 int res1 = 0 ;
40522 bool temp2 = false ;
40523 PyObject * obj0 = 0 ;
40524 PyObject * obj1 = 0 ;
40525 char * kwnames[] = {
40526 (char *) "self",(char *) "title", NULL
40527 };
40528
40529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40533 }
40534 arg1 = reinterpret_cast< wxMenu * >(argp1);
40535 {
40536 arg2 = wxString_in_helper(obj1);
40537 if (arg2 == NULL) SWIG_fail;
40538 temp2 = true;
40539 }
40540 {
40541 PyThreadState* __tstate = wxPyBeginAllowThreads();
40542 (arg1)->SetTitle((wxString const &)*arg2);
40543 wxPyEndAllowThreads(__tstate);
40544 if (PyErr_Occurred()) SWIG_fail;
40545 }
40546 resultobj = SWIG_Py_Void();
40547 {
40548 if (temp2)
40549 delete arg2;
40550 }
40551 return resultobj;
40552 fail:
40553 {
40554 if (temp2)
40555 delete arg2;
40556 }
40557 return NULL;
40558 }
40559
40560
40561 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40562 PyObject *resultobj = 0;
40563 wxMenu *arg1 = (wxMenu *) 0 ;
40564 wxString result;
40565 void *argp1 = 0 ;
40566 int res1 = 0 ;
40567 PyObject *swig_obj[1] ;
40568
40569 if (!args) SWIG_fail;
40570 swig_obj[0] = args;
40571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40572 if (!SWIG_IsOK(res1)) {
40573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40574 }
40575 arg1 = reinterpret_cast< wxMenu * >(argp1);
40576 {
40577 PyThreadState* __tstate = wxPyBeginAllowThreads();
40578 result = ((wxMenu const *)arg1)->GetTitle();
40579 wxPyEndAllowThreads(__tstate);
40580 if (PyErr_Occurred()) SWIG_fail;
40581 }
40582 {
40583 #if wxUSE_UNICODE
40584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40585 #else
40586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40587 #endif
40588 }
40589 return resultobj;
40590 fail:
40591 return NULL;
40592 }
40593
40594
40595 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40596 PyObject *resultobj = 0;
40597 wxMenu *arg1 = (wxMenu *) 0 ;
40598 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40599 void *argp1 = 0 ;
40600 int res1 = 0 ;
40601 void *argp2 = 0 ;
40602 int res2 = 0 ;
40603 PyObject * obj0 = 0 ;
40604 PyObject * obj1 = 0 ;
40605 char * kwnames[] = {
40606 (char *) "self",(char *) "handler", NULL
40607 };
40608
40609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40611 if (!SWIG_IsOK(res1)) {
40612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40613 }
40614 arg1 = reinterpret_cast< wxMenu * >(argp1);
40615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40616 if (!SWIG_IsOK(res2)) {
40617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40618 }
40619 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40620 {
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 (arg1)->SetEventHandler(arg2);
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_Py_Void();
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40634 PyObject *resultobj = 0;
40635 wxMenu *arg1 = (wxMenu *) 0 ;
40636 wxEvtHandler *result = 0 ;
40637 void *argp1 = 0 ;
40638 int res1 = 0 ;
40639 PyObject *swig_obj[1] ;
40640
40641 if (!args) SWIG_fail;
40642 swig_obj[0] = args;
40643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40644 if (!SWIG_IsOK(res1)) {
40645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40646 }
40647 arg1 = reinterpret_cast< wxMenu * >(argp1);
40648 {
40649 PyThreadState* __tstate = wxPyBeginAllowThreads();
40650 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40651 wxPyEndAllowThreads(__tstate);
40652 if (PyErr_Occurred()) SWIG_fail;
40653 }
40654 {
40655 resultobj = wxPyMake_wxObject(result, 0);
40656 }
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40664 PyObject *resultobj = 0;
40665 wxMenu *arg1 = (wxMenu *) 0 ;
40666 wxWindow *arg2 = (wxWindow *) 0 ;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 void *argp2 = 0 ;
40670 int res2 = 0 ;
40671 PyObject * obj0 = 0 ;
40672 PyObject * obj1 = 0 ;
40673 char * kwnames[] = {
40674 (char *) "self",(char *) "win", NULL
40675 };
40676
40677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40679 if (!SWIG_IsOK(res1)) {
40680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40681 }
40682 arg1 = reinterpret_cast< wxMenu * >(argp1);
40683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40684 if (!SWIG_IsOK(res2)) {
40685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40686 }
40687 arg2 = reinterpret_cast< wxWindow * >(argp2);
40688 {
40689 PyThreadState* __tstate = wxPyBeginAllowThreads();
40690 (arg1)->SetInvokingWindow(arg2);
40691 wxPyEndAllowThreads(__tstate);
40692 if (PyErr_Occurred()) SWIG_fail;
40693 }
40694 resultobj = SWIG_Py_Void();
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40702 PyObject *resultobj = 0;
40703 wxMenu *arg1 = (wxMenu *) 0 ;
40704 wxWindow *result = 0 ;
40705 void *argp1 = 0 ;
40706 int res1 = 0 ;
40707 PyObject *swig_obj[1] ;
40708
40709 if (!args) SWIG_fail;
40710 swig_obj[0] = args;
40711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40712 if (!SWIG_IsOK(res1)) {
40713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40714 }
40715 arg1 = reinterpret_cast< wxMenu * >(argp1);
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40719 wxPyEndAllowThreads(__tstate);
40720 if (PyErr_Occurred()) SWIG_fail;
40721 }
40722 {
40723 resultobj = wxPyMake_wxObject(result, 0);
40724 }
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40732 PyObject *resultobj = 0;
40733 wxMenu *arg1 = (wxMenu *) 0 ;
40734 long result;
40735 void *argp1 = 0 ;
40736 int res1 = 0 ;
40737 PyObject *swig_obj[1] ;
40738
40739 if (!args) SWIG_fail;
40740 swig_obj[0] = args;
40741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40742 if (!SWIG_IsOK(res1)) {
40743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40744 }
40745 arg1 = reinterpret_cast< wxMenu * >(argp1);
40746 {
40747 PyThreadState* __tstate = wxPyBeginAllowThreads();
40748 result = (long)((wxMenu const *)arg1)->GetStyle();
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 resultobj = SWIG_From_long(static_cast< long >(result));
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40760 PyObject *resultobj = 0;
40761 wxMenu *arg1 = (wxMenu *) 0 ;
40762 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 void *argp2 = 0 ;
40766 int res2 = 0 ;
40767 PyObject * obj0 = 0 ;
40768 PyObject * obj1 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "source", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40777 }
40778 arg1 = reinterpret_cast< wxMenu * >(argp1);
40779 if (obj1) {
40780 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40781 if (!SWIG_IsOK(res2)) {
40782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40783 }
40784 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40785 }
40786 {
40787 PyThreadState* __tstate = wxPyBeginAllowThreads();
40788 (arg1)->UpdateUI(arg2);
40789 wxPyEndAllowThreads(__tstate);
40790 if (PyErr_Occurred()) SWIG_fail;
40791 }
40792 resultobj = SWIG_Py_Void();
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40800 PyObject *resultobj = 0;
40801 wxMenu *arg1 = (wxMenu *) 0 ;
40802 wxMenuBar *result = 0 ;
40803 void *argp1 = 0 ;
40804 int res1 = 0 ;
40805 PyObject *swig_obj[1] ;
40806
40807 if (!args) SWIG_fail;
40808 swig_obj[0] = args;
40809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40810 if (!SWIG_IsOK(res1)) {
40811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40812 }
40813 arg1 = reinterpret_cast< wxMenu * >(argp1);
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40817 wxPyEndAllowThreads(__tstate);
40818 if (PyErr_Occurred()) SWIG_fail;
40819 }
40820 {
40821 resultobj = wxPyMake_wxObject(result, (bool)0);
40822 }
40823 return resultobj;
40824 fail:
40825 return NULL;
40826 }
40827
40828
40829 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40830 PyObject *resultobj = 0;
40831 wxMenu *arg1 = (wxMenu *) 0 ;
40832 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40833 void *argp1 = 0 ;
40834 int res1 = 0 ;
40835 void *argp2 = 0 ;
40836 int res2 = 0 ;
40837 PyObject * obj0 = 0 ;
40838 PyObject * obj1 = 0 ;
40839 char * kwnames[] = {
40840 (char *) "self",(char *) "menubar", NULL
40841 };
40842
40843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40845 if (!SWIG_IsOK(res1)) {
40846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40847 }
40848 arg1 = reinterpret_cast< wxMenu * >(argp1);
40849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40850 if (!SWIG_IsOK(res2)) {
40851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40852 }
40853 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40854 {
40855 PyThreadState* __tstate = wxPyBeginAllowThreads();
40856 (arg1)->Attach(arg2);
40857 wxPyEndAllowThreads(__tstate);
40858 if (PyErr_Occurred()) SWIG_fail;
40859 }
40860 resultobj = SWIG_Py_Void();
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40868 PyObject *resultobj = 0;
40869 wxMenu *arg1 = (wxMenu *) 0 ;
40870 void *argp1 = 0 ;
40871 int res1 = 0 ;
40872 PyObject *swig_obj[1] ;
40873
40874 if (!args) SWIG_fail;
40875 swig_obj[0] = args;
40876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40877 if (!SWIG_IsOK(res1)) {
40878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40879 }
40880 arg1 = reinterpret_cast< wxMenu * >(argp1);
40881 {
40882 PyThreadState* __tstate = wxPyBeginAllowThreads();
40883 (arg1)->Detach();
40884 wxPyEndAllowThreads(__tstate);
40885 if (PyErr_Occurred()) SWIG_fail;
40886 }
40887 resultobj = SWIG_Py_Void();
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40895 PyObject *resultobj = 0;
40896 wxMenu *arg1 = (wxMenu *) 0 ;
40897 bool result;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 PyObject *swig_obj[1] ;
40901
40902 if (!args) SWIG_fail;
40903 swig_obj[0] = args;
40904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40905 if (!SWIG_IsOK(res1)) {
40906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40907 }
40908 arg1 = reinterpret_cast< wxMenu * >(argp1);
40909 {
40910 PyThreadState* __tstate = wxPyBeginAllowThreads();
40911 result = (bool)((wxMenu const *)arg1)->IsAttached();
40912 wxPyEndAllowThreads(__tstate);
40913 if (PyErr_Occurred()) SWIG_fail;
40914 }
40915 {
40916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40917 }
40918 return resultobj;
40919 fail:
40920 return NULL;
40921 }
40922
40923
40924 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40925 PyObject *resultobj = 0;
40926 wxMenu *arg1 = (wxMenu *) 0 ;
40927 wxMenu *arg2 = (wxMenu *) 0 ;
40928 void *argp1 = 0 ;
40929 int res1 = 0 ;
40930 void *argp2 = 0 ;
40931 int res2 = 0 ;
40932 PyObject * obj0 = 0 ;
40933 PyObject * obj1 = 0 ;
40934 char * kwnames[] = {
40935 (char *) "self",(char *) "parent", NULL
40936 };
40937
40938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40940 if (!SWIG_IsOK(res1)) {
40941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40942 }
40943 arg1 = reinterpret_cast< wxMenu * >(argp1);
40944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40945 if (!SWIG_IsOK(res2)) {
40946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40947 }
40948 arg2 = reinterpret_cast< wxMenu * >(argp2);
40949 {
40950 PyThreadState* __tstate = wxPyBeginAllowThreads();
40951 (arg1)->SetParent(arg2);
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 resultobj = SWIG_Py_Void();
40956 return resultobj;
40957 fail:
40958 return NULL;
40959 }
40960
40961
40962 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40963 PyObject *resultobj = 0;
40964 wxMenu *arg1 = (wxMenu *) 0 ;
40965 wxMenu *result = 0 ;
40966 void *argp1 = 0 ;
40967 int res1 = 0 ;
40968 PyObject *swig_obj[1] ;
40969
40970 if (!args) SWIG_fail;
40971 swig_obj[0] = args;
40972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40973 if (!SWIG_IsOK(res1)) {
40974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40975 }
40976 arg1 = reinterpret_cast< wxMenu * >(argp1);
40977 {
40978 PyThreadState* __tstate = wxPyBeginAllowThreads();
40979 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40980 wxPyEndAllowThreads(__tstate);
40981 if (PyErr_Occurred()) SWIG_fail;
40982 }
40983 {
40984 resultobj = wxPyMake_wxObject(result, 0);
40985 }
40986 return resultobj;
40987 fail:
40988 return NULL;
40989 }
40990
40991
40992 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40993 PyObject *obj;
40994 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40995 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40996 return SWIG_Py_Void();
40997 }
40998
40999 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41000 return SWIG_Python_InitShadowInstance(args);
41001 }
41002
41003 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj = 0;
41005 long arg1 = (long) 0 ;
41006 wxMenuBar *result = 0 ;
41007 long val1 ;
41008 int ecode1 = 0 ;
41009 PyObject * obj0 = 0 ;
41010 char * kwnames[] = {
41011 (char *) "style", NULL
41012 };
41013
41014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41015 if (obj0) {
41016 ecode1 = SWIG_AsVal_long(obj0, &val1);
41017 if (!SWIG_IsOK(ecode1)) {
41018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41019 }
41020 arg1 = static_cast< long >(val1);
41021 }
41022 {
41023 if (!wxPyCheckForApp()) SWIG_fail;
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (wxMenuBar *)new wxMenuBar(arg1);
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41030 return resultobj;
41031 fail:
41032 return NULL;
41033 }
41034
41035
41036 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41037 PyObject *resultobj = 0;
41038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41039 wxMenu *arg2 = (wxMenu *) 0 ;
41040 wxString *arg3 = 0 ;
41041 bool result;
41042 void *argp1 = 0 ;
41043 int res1 = 0 ;
41044 void *argp2 = 0 ;
41045 int res2 = 0 ;
41046 bool temp3 = false ;
41047 PyObject * obj0 = 0 ;
41048 PyObject * obj1 = 0 ;
41049 PyObject * obj2 = 0 ;
41050 char * kwnames[] = {
41051 (char *) "self",(char *) "menu",(char *) "title", NULL
41052 };
41053
41054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41056 if (!SWIG_IsOK(res1)) {
41057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41058 }
41059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41061 if (!SWIG_IsOK(res2)) {
41062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41063 }
41064 arg2 = reinterpret_cast< wxMenu * >(argp2);
41065 {
41066 arg3 = wxString_in_helper(obj2);
41067 if (arg3 == NULL) SWIG_fail;
41068 temp3 = true;
41069 }
41070 {
41071 PyThreadState* __tstate = wxPyBeginAllowThreads();
41072 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41073 wxPyEndAllowThreads(__tstate);
41074 if (PyErr_Occurred()) SWIG_fail;
41075 }
41076 {
41077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41078 }
41079 {
41080 if (temp3)
41081 delete arg3;
41082 }
41083 return resultobj;
41084 fail:
41085 {
41086 if (temp3)
41087 delete arg3;
41088 }
41089 return NULL;
41090 }
41091
41092
41093 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = 0;
41095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41096 size_t arg2 ;
41097 wxMenu *arg3 = (wxMenu *) 0 ;
41098 wxString *arg4 = 0 ;
41099 bool result;
41100 void *argp1 = 0 ;
41101 int res1 = 0 ;
41102 size_t val2 ;
41103 int ecode2 = 0 ;
41104 void *argp3 = 0 ;
41105 int res3 = 0 ;
41106 bool temp4 = false ;
41107 PyObject * obj0 = 0 ;
41108 PyObject * obj1 = 0 ;
41109 PyObject * obj2 = 0 ;
41110 PyObject * obj3 = 0 ;
41111 char * kwnames[] = {
41112 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41113 };
41114
41115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41117 if (!SWIG_IsOK(res1)) {
41118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41119 }
41120 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41121 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41122 if (!SWIG_IsOK(ecode2)) {
41123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41124 }
41125 arg2 = static_cast< size_t >(val2);
41126 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41127 if (!SWIG_IsOK(res3)) {
41128 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41129 }
41130 arg3 = reinterpret_cast< wxMenu * >(argp3);
41131 {
41132 arg4 = wxString_in_helper(obj3);
41133 if (arg4 == NULL) SWIG_fail;
41134 temp4 = true;
41135 }
41136 {
41137 PyThreadState* __tstate = wxPyBeginAllowThreads();
41138 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41139 wxPyEndAllowThreads(__tstate);
41140 if (PyErr_Occurred()) SWIG_fail;
41141 }
41142 {
41143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41144 }
41145 {
41146 if (temp4)
41147 delete arg4;
41148 }
41149 return resultobj;
41150 fail:
41151 {
41152 if (temp4)
41153 delete arg4;
41154 }
41155 return NULL;
41156 }
41157
41158
41159 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41160 PyObject *resultobj = 0;
41161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41162 size_t result;
41163 void *argp1 = 0 ;
41164 int res1 = 0 ;
41165 PyObject *swig_obj[1] ;
41166
41167 if (!args) SWIG_fail;
41168 swig_obj[0] = args;
41169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41172 }
41173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41174 {
41175 PyThreadState* __tstate = wxPyBeginAllowThreads();
41176 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41181 return resultobj;
41182 fail:
41183 return NULL;
41184 }
41185
41186
41187 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41188 PyObject *resultobj = 0;
41189 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41190 size_t arg2 ;
41191 wxMenu *result = 0 ;
41192 void *argp1 = 0 ;
41193 int res1 = 0 ;
41194 size_t val2 ;
41195 int ecode2 = 0 ;
41196 PyObject * obj0 = 0 ;
41197 PyObject * obj1 = 0 ;
41198 char * kwnames[] = {
41199 (char *) "self",(char *) "pos", NULL
41200 };
41201
41202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41204 if (!SWIG_IsOK(res1)) {
41205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41206 }
41207 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41208 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41209 if (!SWIG_IsOK(ecode2)) {
41210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41211 }
41212 arg2 = static_cast< size_t >(val2);
41213 {
41214 PyThreadState* __tstate = wxPyBeginAllowThreads();
41215 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41216 wxPyEndAllowThreads(__tstate);
41217 if (PyErr_Occurred()) SWIG_fail;
41218 }
41219 {
41220 resultobj = wxPyMake_wxObject(result, 0);
41221 }
41222 return resultobj;
41223 fail:
41224 return NULL;
41225 }
41226
41227
41228 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41229 PyObject *resultobj = 0;
41230 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41231 size_t arg2 ;
41232 wxMenu *arg3 = (wxMenu *) 0 ;
41233 wxString *arg4 = 0 ;
41234 wxMenu *result = 0 ;
41235 void *argp1 = 0 ;
41236 int res1 = 0 ;
41237 size_t val2 ;
41238 int ecode2 = 0 ;
41239 void *argp3 = 0 ;
41240 int res3 = 0 ;
41241 bool temp4 = false ;
41242 PyObject * obj0 = 0 ;
41243 PyObject * obj1 = 0 ;
41244 PyObject * obj2 = 0 ;
41245 PyObject * obj3 = 0 ;
41246 char * kwnames[] = {
41247 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41248 };
41249
41250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41252 if (!SWIG_IsOK(res1)) {
41253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41254 }
41255 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41256 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41257 if (!SWIG_IsOK(ecode2)) {
41258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41259 }
41260 arg2 = static_cast< size_t >(val2);
41261 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41262 if (!SWIG_IsOK(res3)) {
41263 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41264 }
41265 arg3 = reinterpret_cast< wxMenu * >(argp3);
41266 {
41267 arg4 = wxString_in_helper(obj3);
41268 if (arg4 == NULL) SWIG_fail;
41269 temp4 = true;
41270 }
41271 {
41272 PyThreadState* __tstate = wxPyBeginAllowThreads();
41273 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 {
41278 resultobj = wxPyMake_wxObject(result, 0);
41279 }
41280 {
41281 if (temp4)
41282 delete arg4;
41283 }
41284 return resultobj;
41285 fail:
41286 {
41287 if (temp4)
41288 delete arg4;
41289 }
41290 return NULL;
41291 }
41292
41293
41294 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41295 PyObject *resultobj = 0;
41296 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41297 size_t arg2 ;
41298 wxMenu *result = 0 ;
41299 void *argp1 = 0 ;
41300 int res1 = 0 ;
41301 size_t val2 ;
41302 int ecode2 = 0 ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 char * kwnames[] = {
41306 (char *) "self",(char *) "pos", NULL
41307 };
41308
41309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41311 if (!SWIG_IsOK(res1)) {
41312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41313 }
41314 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41315 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41316 if (!SWIG_IsOK(ecode2)) {
41317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41318 }
41319 arg2 = static_cast< size_t >(val2);
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 result = (wxMenu *)(arg1)->Remove(arg2);
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 {
41327 resultobj = wxPyMake_wxObject(result, 0);
41328 }
41329 return resultobj;
41330 fail:
41331 return NULL;
41332 }
41333
41334
41335 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41336 PyObject *resultobj = 0;
41337 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41338 size_t arg2 ;
41339 bool arg3 ;
41340 void *argp1 = 0 ;
41341 int res1 = 0 ;
41342 size_t val2 ;
41343 int ecode2 = 0 ;
41344 bool val3 ;
41345 int ecode3 = 0 ;
41346 PyObject * obj0 = 0 ;
41347 PyObject * obj1 = 0 ;
41348 PyObject * obj2 = 0 ;
41349 char * kwnames[] = {
41350 (char *) "self",(char *) "pos",(char *) "enable", NULL
41351 };
41352
41353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41355 if (!SWIG_IsOK(res1)) {
41356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41357 }
41358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41359 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41360 if (!SWIG_IsOK(ecode2)) {
41361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41362 }
41363 arg2 = static_cast< size_t >(val2);
41364 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41365 if (!SWIG_IsOK(ecode3)) {
41366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41367 }
41368 arg3 = static_cast< bool >(val3);
41369 {
41370 PyThreadState* __tstate = wxPyBeginAllowThreads();
41371 (arg1)->EnableTop(arg2,arg3);
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 resultobj = SWIG_Py_Void();
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj = 0;
41384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41385 size_t arg2 ;
41386 bool result;
41387 void *argp1 = 0 ;
41388 int res1 = 0 ;
41389 size_t val2 ;
41390 int ecode2 = 0 ;
41391 PyObject * obj0 = 0 ;
41392 PyObject * obj1 = 0 ;
41393 char * kwnames[] = {
41394 (char *) "self",(char *) "pos", NULL
41395 };
41396
41397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41401 }
41402 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41403 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41404 if (!SWIG_IsOK(ecode2)) {
41405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41406 }
41407 arg2 = static_cast< size_t >(val2);
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41411 wxPyEndAllowThreads(__tstate);
41412 if (PyErr_Occurred()) SWIG_fail;
41413 }
41414 {
41415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41416 }
41417 return resultobj;
41418 fail:
41419 return NULL;
41420 }
41421
41422
41423 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41424 PyObject *resultobj = 0;
41425 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41426 size_t arg2 ;
41427 wxString *arg3 = 0 ;
41428 void *argp1 = 0 ;
41429 int res1 = 0 ;
41430 size_t val2 ;
41431 int ecode2 = 0 ;
41432 bool temp3 = false ;
41433 PyObject * obj0 = 0 ;
41434 PyObject * obj1 = 0 ;
41435 PyObject * obj2 = 0 ;
41436 char * kwnames[] = {
41437 (char *) "self",(char *) "pos",(char *) "label", NULL
41438 };
41439
41440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41442 if (!SWIG_IsOK(res1)) {
41443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41444 }
41445 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41446 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41447 if (!SWIG_IsOK(ecode2)) {
41448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41449 }
41450 arg2 = static_cast< size_t >(val2);
41451 {
41452 arg3 = wxString_in_helper(obj2);
41453 if (arg3 == NULL) SWIG_fail;
41454 temp3 = true;
41455 }
41456 {
41457 PyThreadState* __tstate = wxPyBeginAllowThreads();
41458 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 resultobj = SWIG_Py_Void();
41463 {
41464 if (temp3)
41465 delete arg3;
41466 }
41467 return resultobj;
41468 fail:
41469 {
41470 if (temp3)
41471 delete arg3;
41472 }
41473 return NULL;
41474 }
41475
41476
41477 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41478 PyObject *resultobj = 0;
41479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41480 size_t arg2 ;
41481 wxString result;
41482 void *argp1 = 0 ;
41483 int res1 = 0 ;
41484 size_t val2 ;
41485 int ecode2 = 0 ;
41486 PyObject * obj0 = 0 ;
41487 PyObject * obj1 = 0 ;
41488 char * kwnames[] = {
41489 (char *) "self",(char *) "pos", NULL
41490 };
41491
41492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41494 if (!SWIG_IsOK(res1)) {
41495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41496 }
41497 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41498 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41499 if (!SWIG_IsOK(ecode2)) {
41500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41501 }
41502 arg2 = static_cast< size_t >(val2);
41503 {
41504 PyThreadState* __tstate = wxPyBeginAllowThreads();
41505 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41506 wxPyEndAllowThreads(__tstate);
41507 if (PyErr_Occurred()) SWIG_fail;
41508 }
41509 {
41510 #if wxUSE_UNICODE
41511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41512 #else
41513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41514 #endif
41515 }
41516 return resultobj;
41517 fail:
41518 return NULL;
41519 }
41520
41521
41522 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = 0;
41524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41525 wxString *arg2 = 0 ;
41526 wxString *arg3 = 0 ;
41527 int result;
41528 void *argp1 = 0 ;
41529 int res1 = 0 ;
41530 bool temp2 = false ;
41531 bool temp3 = false ;
41532 PyObject * obj0 = 0 ;
41533 PyObject * obj1 = 0 ;
41534 PyObject * obj2 = 0 ;
41535 char * kwnames[] = {
41536 (char *) "self",(char *) "menu",(char *) "item", NULL
41537 };
41538
41539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41541 if (!SWIG_IsOK(res1)) {
41542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41543 }
41544 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41545 {
41546 arg2 = wxString_in_helper(obj1);
41547 if (arg2 == NULL) SWIG_fail;
41548 temp2 = true;
41549 }
41550 {
41551 arg3 = wxString_in_helper(obj2);
41552 if (arg3 == NULL) SWIG_fail;
41553 temp3 = true;
41554 }
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 resultobj = SWIG_From_int(static_cast< int >(result));
41562 {
41563 if (temp2)
41564 delete arg2;
41565 }
41566 {
41567 if (temp3)
41568 delete arg3;
41569 }
41570 return resultobj;
41571 fail:
41572 {
41573 if (temp2)
41574 delete arg2;
41575 }
41576 {
41577 if (temp3)
41578 delete arg3;
41579 }
41580 return NULL;
41581 }
41582
41583
41584 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41585 PyObject *resultobj = 0;
41586 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41587 int arg2 ;
41588 wxMenuItem *result = 0 ;
41589 void *argp1 = 0 ;
41590 int res1 = 0 ;
41591 int val2 ;
41592 int ecode2 = 0 ;
41593 PyObject * obj0 = 0 ;
41594 PyObject * obj1 = 0 ;
41595 char * kwnames[] = {
41596 (char *) "self",(char *) "id", NULL
41597 };
41598
41599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41601 if (!SWIG_IsOK(res1)) {
41602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41603 }
41604 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41605 ecode2 = SWIG_AsVal_int(obj1, &val2);
41606 if (!SWIG_IsOK(ecode2)) {
41607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41608 }
41609 arg2 = static_cast< int >(val2);
41610 {
41611 PyThreadState* __tstate = wxPyBeginAllowThreads();
41612 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41613 wxPyEndAllowThreads(__tstate);
41614 if (PyErr_Occurred()) SWIG_fail;
41615 }
41616 {
41617 resultobj = wxPyMake_wxObject(result, (bool)0);
41618 }
41619 return resultobj;
41620 fail:
41621 return NULL;
41622 }
41623
41624
41625 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41626 PyObject *resultobj = 0;
41627 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41628 wxString *arg2 = 0 ;
41629 int result;
41630 void *argp1 = 0 ;
41631 int res1 = 0 ;
41632 bool temp2 = false ;
41633 PyObject * obj0 = 0 ;
41634 PyObject * obj1 = 0 ;
41635 char * kwnames[] = {
41636 (char *) "self",(char *) "title", NULL
41637 };
41638
41639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41641 if (!SWIG_IsOK(res1)) {
41642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41643 }
41644 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41645 {
41646 arg2 = wxString_in_helper(obj1);
41647 if (arg2 == NULL) SWIG_fail;
41648 temp2 = true;
41649 }
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 resultobj = SWIG_From_int(static_cast< int >(result));
41657 {
41658 if (temp2)
41659 delete arg2;
41660 }
41661 return resultobj;
41662 fail:
41663 {
41664 if (temp2)
41665 delete arg2;
41666 }
41667 return NULL;
41668 }
41669
41670
41671 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41672 PyObject *resultobj = 0;
41673 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41674 int arg2 ;
41675 bool arg3 ;
41676 void *argp1 = 0 ;
41677 int res1 = 0 ;
41678 int val2 ;
41679 int ecode2 = 0 ;
41680 bool val3 ;
41681 int ecode3 = 0 ;
41682 PyObject * obj0 = 0 ;
41683 PyObject * obj1 = 0 ;
41684 PyObject * obj2 = 0 ;
41685 char * kwnames[] = {
41686 (char *) "self",(char *) "id",(char *) "enable", NULL
41687 };
41688
41689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41691 if (!SWIG_IsOK(res1)) {
41692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41693 }
41694 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41695 ecode2 = SWIG_AsVal_int(obj1, &val2);
41696 if (!SWIG_IsOK(ecode2)) {
41697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41698 }
41699 arg2 = static_cast< int >(val2);
41700 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41701 if (!SWIG_IsOK(ecode3)) {
41702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41703 }
41704 arg3 = static_cast< bool >(val3);
41705 {
41706 PyThreadState* __tstate = wxPyBeginAllowThreads();
41707 (arg1)->Enable(arg2,arg3);
41708 wxPyEndAllowThreads(__tstate);
41709 if (PyErr_Occurred()) SWIG_fail;
41710 }
41711 resultobj = SWIG_Py_Void();
41712 return resultobj;
41713 fail:
41714 return NULL;
41715 }
41716
41717
41718 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41719 PyObject *resultobj = 0;
41720 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41721 int arg2 ;
41722 bool arg3 ;
41723 void *argp1 = 0 ;
41724 int res1 = 0 ;
41725 int val2 ;
41726 int ecode2 = 0 ;
41727 bool val3 ;
41728 int ecode3 = 0 ;
41729 PyObject * obj0 = 0 ;
41730 PyObject * obj1 = 0 ;
41731 PyObject * obj2 = 0 ;
41732 char * kwnames[] = {
41733 (char *) "self",(char *) "id",(char *) "check", NULL
41734 };
41735
41736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41738 if (!SWIG_IsOK(res1)) {
41739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41740 }
41741 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41742 ecode2 = SWIG_AsVal_int(obj1, &val2);
41743 if (!SWIG_IsOK(ecode2)) {
41744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41745 }
41746 arg2 = static_cast< int >(val2);
41747 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41748 if (!SWIG_IsOK(ecode3)) {
41749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41750 }
41751 arg3 = static_cast< bool >(val3);
41752 {
41753 PyThreadState* __tstate = wxPyBeginAllowThreads();
41754 (arg1)->Check(arg2,arg3);
41755 wxPyEndAllowThreads(__tstate);
41756 if (PyErr_Occurred()) SWIG_fail;
41757 }
41758 resultobj = SWIG_Py_Void();
41759 return resultobj;
41760 fail:
41761 return NULL;
41762 }
41763
41764
41765 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41766 PyObject *resultobj = 0;
41767 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41768 int arg2 ;
41769 bool result;
41770 void *argp1 = 0 ;
41771 int res1 = 0 ;
41772 int val2 ;
41773 int ecode2 = 0 ;
41774 PyObject * obj0 = 0 ;
41775 PyObject * obj1 = 0 ;
41776 char * kwnames[] = {
41777 (char *) "self",(char *) "id", NULL
41778 };
41779
41780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41782 if (!SWIG_IsOK(res1)) {
41783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41784 }
41785 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41786 ecode2 = SWIG_AsVal_int(obj1, &val2);
41787 if (!SWIG_IsOK(ecode2)) {
41788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41789 }
41790 arg2 = static_cast< int >(val2);
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 {
41798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41799 }
41800 return resultobj;
41801 fail:
41802 return NULL;
41803 }
41804
41805
41806 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41807 PyObject *resultobj = 0;
41808 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41809 int arg2 ;
41810 bool result;
41811 void *argp1 = 0 ;
41812 int res1 = 0 ;
41813 int val2 ;
41814 int ecode2 = 0 ;
41815 PyObject * obj0 = 0 ;
41816 PyObject * obj1 = 0 ;
41817 char * kwnames[] = {
41818 (char *) "self",(char *) "id", NULL
41819 };
41820
41821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41823 if (!SWIG_IsOK(res1)) {
41824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41825 }
41826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41827 ecode2 = SWIG_AsVal_int(obj1, &val2);
41828 if (!SWIG_IsOK(ecode2)) {
41829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41830 }
41831 arg2 = static_cast< int >(val2);
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41835 wxPyEndAllowThreads(__tstate);
41836 if (PyErr_Occurred()) SWIG_fail;
41837 }
41838 {
41839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41840 }
41841 return resultobj;
41842 fail:
41843 return NULL;
41844 }
41845
41846
41847 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41848 PyObject *resultobj = 0;
41849 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41850 int arg2 ;
41851 wxString *arg3 = 0 ;
41852 void *argp1 = 0 ;
41853 int res1 = 0 ;
41854 int val2 ;
41855 int ecode2 = 0 ;
41856 bool temp3 = false ;
41857 PyObject * obj0 = 0 ;
41858 PyObject * obj1 = 0 ;
41859 PyObject * obj2 = 0 ;
41860 char * kwnames[] = {
41861 (char *) "self",(char *) "id",(char *) "label", NULL
41862 };
41863
41864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41866 if (!SWIG_IsOK(res1)) {
41867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41868 }
41869 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41870 ecode2 = SWIG_AsVal_int(obj1, &val2);
41871 if (!SWIG_IsOK(ecode2)) {
41872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41873 }
41874 arg2 = static_cast< int >(val2);
41875 {
41876 arg3 = wxString_in_helper(obj2);
41877 if (arg3 == NULL) SWIG_fail;
41878 temp3 = true;
41879 }
41880 {
41881 PyThreadState* __tstate = wxPyBeginAllowThreads();
41882 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 resultobj = SWIG_Py_Void();
41887 {
41888 if (temp3)
41889 delete arg3;
41890 }
41891 return resultobj;
41892 fail:
41893 {
41894 if (temp3)
41895 delete arg3;
41896 }
41897 return NULL;
41898 }
41899
41900
41901 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41902 PyObject *resultobj = 0;
41903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41904 int arg2 ;
41905 wxString result;
41906 void *argp1 = 0 ;
41907 int res1 = 0 ;
41908 int val2 ;
41909 int ecode2 = 0 ;
41910 PyObject * obj0 = 0 ;
41911 PyObject * obj1 = 0 ;
41912 char * kwnames[] = {
41913 (char *) "self",(char *) "id", NULL
41914 };
41915
41916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41918 if (!SWIG_IsOK(res1)) {
41919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41920 }
41921 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41922 ecode2 = SWIG_AsVal_int(obj1, &val2);
41923 if (!SWIG_IsOK(ecode2)) {
41924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41925 }
41926 arg2 = static_cast< int >(val2);
41927 {
41928 PyThreadState* __tstate = wxPyBeginAllowThreads();
41929 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41930 wxPyEndAllowThreads(__tstate);
41931 if (PyErr_Occurred()) SWIG_fail;
41932 }
41933 {
41934 #if wxUSE_UNICODE
41935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41936 #else
41937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41938 #endif
41939 }
41940 return resultobj;
41941 fail:
41942 return NULL;
41943 }
41944
41945
41946 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41947 PyObject *resultobj = 0;
41948 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41949 int arg2 ;
41950 wxString *arg3 = 0 ;
41951 void *argp1 = 0 ;
41952 int res1 = 0 ;
41953 int val2 ;
41954 int ecode2 = 0 ;
41955 bool temp3 = false ;
41956 PyObject * obj0 = 0 ;
41957 PyObject * obj1 = 0 ;
41958 PyObject * obj2 = 0 ;
41959 char * kwnames[] = {
41960 (char *) "self",(char *) "id",(char *) "helpString", NULL
41961 };
41962
41963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41965 if (!SWIG_IsOK(res1)) {
41966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41967 }
41968 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41969 ecode2 = SWIG_AsVal_int(obj1, &val2);
41970 if (!SWIG_IsOK(ecode2)) {
41971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41972 }
41973 arg2 = static_cast< int >(val2);
41974 {
41975 arg3 = wxString_in_helper(obj2);
41976 if (arg3 == NULL) SWIG_fail;
41977 temp3 = true;
41978 }
41979 {
41980 PyThreadState* __tstate = wxPyBeginAllowThreads();
41981 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41982 wxPyEndAllowThreads(__tstate);
41983 if (PyErr_Occurred()) SWIG_fail;
41984 }
41985 resultobj = SWIG_Py_Void();
41986 {
41987 if (temp3)
41988 delete arg3;
41989 }
41990 return resultobj;
41991 fail:
41992 {
41993 if (temp3)
41994 delete arg3;
41995 }
41996 return NULL;
41997 }
41998
41999
42000 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42001 PyObject *resultobj = 0;
42002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42003 int arg2 ;
42004 wxString result;
42005 void *argp1 = 0 ;
42006 int res1 = 0 ;
42007 int val2 ;
42008 int ecode2 = 0 ;
42009 PyObject * obj0 = 0 ;
42010 PyObject * obj1 = 0 ;
42011 char * kwnames[] = {
42012 (char *) "self",(char *) "id", NULL
42013 };
42014
42015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42017 if (!SWIG_IsOK(res1)) {
42018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42019 }
42020 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42021 ecode2 = SWIG_AsVal_int(obj1, &val2);
42022 if (!SWIG_IsOK(ecode2)) {
42023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42024 }
42025 arg2 = static_cast< int >(val2);
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42029 wxPyEndAllowThreads(__tstate);
42030 if (PyErr_Occurred()) SWIG_fail;
42031 }
42032 {
42033 #if wxUSE_UNICODE
42034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42035 #else
42036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42037 #endif
42038 }
42039 return resultobj;
42040 fail:
42041 return NULL;
42042 }
42043
42044
42045 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42046 PyObject *resultobj = 0;
42047 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42048 wxFrame *result = 0 ;
42049 void *argp1 = 0 ;
42050 int res1 = 0 ;
42051 PyObject *swig_obj[1] ;
42052
42053 if (!args) SWIG_fail;
42054 swig_obj[0] = args;
42055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42056 if (!SWIG_IsOK(res1)) {
42057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42058 }
42059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42060 {
42061 PyThreadState* __tstate = wxPyBeginAllowThreads();
42062 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42063 wxPyEndAllowThreads(__tstate);
42064 if (PyErr_Occurred()) SWIG_fail;
42065 }
42066 {
42067 resultobj = wxPyMake_wxObject(result, (bool)0);
42068 }
42069 return resultobj;
42070 fail:
42071 return NULL;
42072 }
42073
42074
42075 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42076 PyObject *resultobj = 0;
42077 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42078 bool result;
42079 void *argp1 = 0 ;
42080 int res1 = 0 ;
42081 PyObject *swig_obj[1] ;
42082
42083 if (!args) SWIG_fail;
42084 swig_obj[0] = args;
42085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42086 if (!SWIG_IsOK(res1)) {
42087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42088 }
42089 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42090 {
42091 PyThreadState* __tstate = wxPyBeginAllowThreads();
42092 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42093 wxPyEndAllowThreads(__tstate);
42094 if (PyErr_Occurred()) SWIG_fail;
42095 }
42096 {
42097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42098 }
42099 return resultobj;
42100 fail:
42101 return NULL;
42102 }
42103
42104
42105 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42106 PyObject *resultobj = 0;
42107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42108 wxFrame *arg2 = (wxFrame *) 0 ;
42109 void *argp1 = 0 ;
42110 int res1 = 0 ;
42111 void *argp2 = 0 ;
42112 int res2 = 0 ;
42113 PyObject * obj0 = 0 ;
42114 PyObject * obj1 = 0 ;
42115 char * kwnames[] = {
42116 (char *) "self",(char *) "frame", NULL
42117 };
42118
42119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42121 if (!SWIG_IsOK(res1)) {
42122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42123 }
42124 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42126 if (!SWIG_IsOK(res2)) {
42127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42128 }
42129 arg2 = reinterpret_cast< wxFrame * >(argp2);
42130 {
42131 PyThreadState* __tstate = wxPyBeginAllowThreads();
42132 (arg1)->Attach(arg2);
42133 wxPyEndAllowThreads(__tstate);
42134 if (PyErr_Occurred()) SWIG_fail;
42135 }
42136 resultobj = SWIG_Py_Void();
42137 return resultobj;
42138 fail:
42139 return NULL;
42140 }
42141
42142
42143 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42144 PyObject *resultobj = 0;
42145 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42146 void *argp1 = 0 ;
42147 int res1 = 0 ;
42148 PyObject *swig_obj[1] ;
42149
42150 if (!args) SWIG_fail;
42151 swig_obj[0] = args;
42152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42153 if (!SWIG_IsOK(res1)) {
42154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42155 }
42156 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42157 {
42158 PyThreadState* __tstate = wxPyBeginAllowThreads();
42159 (arg1)->Detach();
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 resultobj = SWIG_Py_Void();
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj = 0;
42172 bool arg1 ;
42173 bool val1 ;
42174 int ecode1 = 0 ;
42175 PyObject * obj0 = 0 ;
42176 char * kwnames[] = {
42177 (char *) "enable", NULL
42178 };
42179
42180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42181 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42182 if (!SWIG_IsOK(ecode1)) {
42183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42184 }
42185 arg1 = static_cast< bool >(val1);
42186 {
42187 PyThreadState* __tstate = wxPyBeginAllowThreads();
42188 wxMenuBar::SetAutoWindowMenu(arg1);
42189 wxPyEndAllowThreads(__tstate);
42190 if (PyErr_Occurred()) SWIG_fail;
42191 }
42192 resultobj = SWIG_Py_Void();
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42200 PyObject *resultobj = 0;
42201 bool result;
42202
42203 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42204 {
42205 PyThreadState* __tstate = wxPyBeginAllowThreads();
42206 result = (bool)wxMenuBar::GetAutoWindowMenu();
42207 wxPyEndAllowThreads(__tstate);
42208 if (PyErr_Occurred()) SWIG_fail;
42209 }
42210 {
42211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42212 }
42213 return resultobj;
42214 fail:
42215 return NULL;
42216 }
42217
42218
42219 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42220 PyObject *obj;
42221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42222 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42223 return SWIG_Py_Void();
42224 }
42225
42226 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42227 return SWIG_Python_InitShadowInstance(args);
42228 }
42229
42230 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42231 PyObject *resultobj = 0;
42232 wxMenu *arg1 = (wxMenu *) NULL ;
42233 int arg2 = (int) wxID_ANY ;
42234 wxString const &arg3_defvalue = wxPyEmptyString ;
42235 wxString *arg3 = (wxString *) &arg3_defvalue ;
42236 wxString const &arg4_defvalue = wxPyEmptyString ;
42237 wxString *arg4 = (wxString *) &arg4_defvalue ;
42238 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42239 wxMenu *arg6 = (wxMenu *) NULL ;
42240 wxMenuItem *result = 0 ;
42241 void *argp1 = 0 ;
42242 int res1 = 0 ;
42243 int val2 ;
42244 int ecode2 = 0 ;
42245 bool temp3 = false ;
42246 bool temp4 = false ;
42247 int val5 ;
42248 int ecode5 = 0 ;
42249 void *argp6 = 0 ;
42250 int res6 = 0 ;
42251 PyObject * obj0 = 0 ;
42252 PyObject * obj1 = 0 ;
42253 PyObject * obj2 = 0 ;
42254 PyObject * obj3 = 0 ;
42255 PyObject * obj4 = 0 ;
42256 PyObject * obj5 = 0 ;
42257 char * kwnames[] = {
42258 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42259 };
42260
42261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42262 if (obj0) {
42263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42264 if (!SWIG_IsOK(res1)) {
42265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42266 }
42267 arg1 = reinterpret_cast< wxMenu * >(argp1);
42268 }
42269 if (obj1) {
42270 ecode2 = SWIG_AsVal_int(obj1, &val2);
42271 if (!SWIG_IsOK(ecode2)) {
42272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42273 }
42274 arg2 = static_cast< int >(val2);
42275 }
42276 if (obj2) {
42277 {
42278 arg3 = wxString_in_helper(obj2);
42279 if (arg3 == NULL) SWIG_fail;
42280 temp3 = true;
42281 }
42282 }
42283 if (obj3) {
42284 {
42285 arg4 = wxString_in_helper(obj3);
42286 if (arg4 == NULL) SWIG_fail;
42287 temp4 = true;
42288 }
42289 }
42290 if (obj4) {
42291 ecode5 = SWIG_AsVal_int(obj4, &val5);
42292 if (!SWIG_IsOK(ecode5)) {
42293 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42294 }
42295 arg5 = static_cast< wxItemKind >(val5);
42296 }
42297 if (obj5) {
42298 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42299 if (!SWIG_IsOK(res6)) {
42300 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42301 }
42302 arg6 = reinterpret_cast< wxMenu * >(argp6);
42303 }
42304 {
42305 PyThreadState* __tstate = wxPyBeginAllowThreads();
42306 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 {
42311 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42312 }
42313 {
42314 if (temp3)
42315 delete arg3;
42316 }
42317 {
42318 if (temp4)
42319 delete arg4;
42320 }
42321 return resultobj;
42322 fail:
42323 {
42324 if (temp3)
42325 delete arg3;
42326 }
42327 {
42328 if (temp4)
42329 delete arg4;
42330 }
42331 return NULL;
42332 }
42333
42334
42335 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42336 PyObject *resultobj = 0;
42337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42338 void *argp1 = 0 ;
42339 int res1 = 0 ;
42340 PyObject *swig_obj[1] ;
42341
42342 if (!args) SWIG_fail;
42343 swig_obj[0] = args;
42344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42345 if (!SWIG_IsOK(res1)) {
42346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42347 }
42348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42349 {
42350 PyThreadState* __tstate = wxPyBeginAllowThreads();
42351 delete arg1;
42352
42353 wxPyEndAllowThreads(__tstate);
42354 if (PyErr_Occurred()) SWIG_fail;
42355 }
42356 resultobj = SWIG_Py_Void();
42357 return resultobj;
42358 fail:
42359 return NULL;
42360 }
42361
42362
42363 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42364 PyObject *resultobj = 0;
42365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42366 wxMenu *result = 0 ;
42367 void *argp1 = 0 ;
42368 int res1 = 0 ;
42369 PyObject *swig_obj[1] ;
42370
42371 if (!args) SWIG_fail;
42372 swig_obj[0] = args;
42373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42374 if (!SWIG_IsOK(res1)) {
42375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42376 }
42377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 {
42385 resultobj = wxPyMake_wxObject(result, 0);
42386 }
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42394 PyObject *resultobj = 0;
42395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42396 wxMenu *arg2 = (wxMenu *) 0 ;
42397 void *argp1 = 0 ;
42398 int res1 = 0 ;
42399 void *argp2 = 0 ;
42400 int res2 = 0 ;
42401 PyObject * obj0 = 0 ;
42402 PyObject * obj1 = 0 ;
42403 char * kwnames[] = {
42404 (char *) "self",(char *) "menu", NULL
42405 };
42406
42407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42409 if (!SWIG_IsOK(res1)) {
42410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42411 }
42412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42414 if (!SWIG_IsOK(res2)) {
42415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42416 }
42417 arg2 = reinterpret_cast< wxMenu * >(argp2);
42418 {
42419 PyThreadState* __tstate = wxPyBeginAllowThreads();
42420 (arg1)->SetMenu(arg2);
42421 wxPyEndAllowThreads(__tstate);
42422 if (PyErr_Occurred()) SWIG_fail;
42423 }
42424 resultobj = SWIG_Py_Void();
42425 return resultobj;
42426 fail:
42427 return NULL;
42428 }
42429
42430
42431 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42432 PyObject *resultobj = 0;
42433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42434 int arg2 ;
42435 void *argp1 = 0 ;
42436 int res1 = 0 ;
42437 int val2 ;
42438 int ecode2 = 0 ;
42439 PyObject * obj0 = 0 ;
42440 PyObject * obj1 = 0 ;
42441 char * kwnames[] = {
42442 (char *) "self",(char *) "id", NULL
42443 };
42444
42445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42447 if (!SWIG_IsOK(res1)) {
42448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42449 }
42450 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42451 ecode2 = SWIG_AsVal_int(obj1, &val2);
42452 if (!SWIG_IsOK(ecode2)) {
42453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42454 }
42455 arg2 = static_cast< int >(val2);
42456 {
42457 PyThreadState* __tstate = wxPyBeginAllowThreads();
42458 (arg1)->SetId(arg2);
42459 wxPyEndAllowThreads(__tstate);
42460 if (PyErr_Occurred()) SWIG_fail;
42461 }
42462 resultobj = SWIG_Py_Void();
42463 return resultobj;
42464 fail:
42465 return NULL;
42466 }
42467
42468
42469 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42470 PyObject *resultobj = 0;
42471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42472 int result;
42473 void *argp1 = 0 ;
42474 int res1 = 0 ;
42475 PyObject *swig_obj[1] ;
42476
42477 if (!args) SWIG_fail;
42478 swig_obj[0] = args;
42479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42480 if (!SWIG_IsOK(res1)) {
42481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42482 }
42483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42484 {
42485 PyThreadState* __tstate = wxPyBeginAllowThreads();
42486 result = (int)((wxMenuItem const *)arg1)->GetId();
42487 wxPyEndAllowThreads(__tstate);
42488 if (PyErr_Occurred()) SWIG_fail;
42489 }
42490 resultobj = SWIG_From_int(static_cast< int >(result));
42491 return resultobj;
42492 fail:
42493 return NULL;
42494 }
42495
42496
42497 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42498 PyObject *resultobj = 0;
42499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42500 bool result;
42501 void *argp1 = 0 ;
42502 int res1 = 0 ;
42503 PyObject *swig_obj[1] ;
42504
42505 if (!args) SWIG_fail;
42506 swig_obj[0] = args;
42507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42510 }
42511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42512 {
42513 PyThreadState* __tstate = wxPyBeginAllowThreads();
42514 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42515 wxPyEndAllowThreads(__tstate);
42516 if (PyErr_Occurred()) SWIG_fail;
42517 }
42518 {
42519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42520 }
42521 return resultobj;
42522 fail:
42523 return NULL;
42524 }
42525
42526
42527 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42528 PyObject *resultobj = 0;
42529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42530 wxString *arg2 = 0 ;
42531 void *argp1 = 0 ;
42532 int res1 = 0 ;
42533 bool temp2 = false ;
42534 PyObject * obj0 = 0 ;
42535 PyObject * obj1 = 0 ;
42536 char * kwnames[] = {
42537 (char *) "self",(char *) "str", NULL
42538 };
42539
42540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42542 if (!SWIG_IsOK(res1)) {
42543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42544 }
42545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42546 {
42547 arg2 = wxString_in_helper(obj1);
42548 if (arg2 == NULL) SWIG_fail;
42549 temp2 = true;
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 (arg1)->SetText((wxString const &)*arg2);
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 resultobj = SWIG_Py_Void();
42558 {
42559 if (temp2)
42560 delete arg2;
42561 }
42562 return resultobj;
42563 fail:
42564 {
42565 if (temp2)
42566 delete arg2;
42567 }
42568 return NULL;
42569 }
42570
42571
42572 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42573 PyObject *resultobj = 0;
42574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42575 wxString result;
42576 void *argp1 = 0 ;
42577 int res1 = 0 ;
42578 PyObject *swig_obj[1] ;
42579
42580 if (!args) SWIG_fail;
42581 swig_obj[0] = args;
42582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42583 if (!SWIG_IsOK(res1)) {
42584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42585 }
42586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42587 {
42588 PyThreadState* __tstate = wxPyBeginAllowThreads();
42589 result = ((wxMenuItem const *)arg1)->GetLabel();
42590 wxPyEndAllowThreads(__tstate);
42591 if (PyErr_Occurred()) SWIG_fail;
42592 }
42593 {
42594 #if wxUSE_UNICODE
42595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42596 #else
42597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42598 #endif
42599 }
42600 return resultobj;
42601 fail:
42602 return NULL;
42603 }
42604
42605
42606 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42607 PyObject *resultobj = 0;
42608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42609 wxString *result = 0 ;
42610 void *argp1 = 0 ;
42611 int res1 = 0 ;
42612 PyObject *swig_obj[1] ;
42613
42614 if (!args) SWIG_fail;
42615 swig_obj[0] = args;
42616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42617 if (!SWIG_IsOK(res1)) {
42618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42619 }
42620 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42621 {
42622 PyThreadState* __tstate = wxPyBeginAllowThreads();
42623 {
42624 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42625 result = (wxString *) &_result_ref;
42626 }
42627 wxPyEndAllowThreads(__tstate);
42628 if (PyErr_Occurred()) SWIG_fail;
42629 }
42630 {
42631 #if wxUSE_UNICODE
42632 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42633 #else
42634 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42635 #endif
42636 }
42637 return resultobj;
42638 fail:
42639 return NULL;
42640 }
42641
42642
42643 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42644 PyObject *resultobj = 0;
42645 wxString *arg1 = 0 ;
42646 wxString result;
42647 bool temp1 = false ;
42648 PyObject * obj0 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "text", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42654 {
42655 arg1 = wxString_in_helper(obj0);
42656 if (arg1 == NULL) SWIG_fail;
42657 temp1 = true;
42658 }
42659 {
42660 PyThreadState* __tstate = wxPyBeginAllowThreads();
42661 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 {
42666 #if wxUSE_UNICODE
42667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42668 #else
42669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42670 #endif
42671 }
42672 {
42673 if (temp1)
42674 delete arg1;
42675 }
42676 return resultobj;
42677 fail:
42678 {
42679 if (temp1)
42680 delete arg1;
42681 }
42682 return NULL;
42683 }
42684
42685
42686 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42687 PyObject *resultobj = 0;
42688 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42689 wxItemKind result;
42690 void *argp1 = 0 ;
42691 int res1 = 0 ;
42692 PyObject *swig_obj[1] ;
42693
42694 if (!args) SWIG_fail;
42695 swig_obj[0] = args;
42696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42701 {
42702 PyThreadState* __tstate = wxPyBeginAllowThreads();
42703 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42704 wxPyEndAllowThreads(__tstate);
42705 if (PyErr_Occurred()) SWIG_fail;
42706 }
42707 resultobj = SWIG_From_int(static_cast< int >(result));
42708 return resultobj;
42709 fail:
42710 return NULL;
42711 }
42712
42713
42714 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42715 PyObject *resultobj = 0;
42716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42717 wxItemKind arg2 ;
42718 void *argp1 = 0 ;
42719 int res1 = 0 ;
42720 int val2 ;
42721 int ecode2 = 0 ;
42722 PyObject * obj0 = 0 ;
42723 PyObject * obj1 = 0 ;
42724 char * kwnames[] = {
42725 (char *) "self",(char *) "kind", NULL
42726 };
42727
42728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42730 if (!SWIG_IsOK(res1)) {
42731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42732 }
42733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42734 ecode2 = SWIG_AsVal_int(obj1, &val2);
42735 if (!SWIG_IsOK(ecode2)) {
42736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42737 }
42738 arg2 = static_cast< wxItemKind >(val2);
42739 {
42740 PyThreadState* __tstate = wxPyBeginAllowThreads();
42741 (arg1)->SetKind(arg2);
42742 wxPyEndAllowThreads(__tstate);
42743 if (PyErr_Occurred()) SWIG_fail;
42744 }
42745 resultobj = SWIG_Py_Void();
42746 return resultobj;
42747 fail:
42748 return NULL;
42749 }
42750
42751
42752 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42753 PyObject *resultobj = 0;
42754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42755 bool arg2 ;
42756 void *argp1 = 0 ;
42757 int res1 = 0 ;
42758 bool val2 ;
42759 int ecode2 = 0 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 char * kwnames[] = {
42763 (char *) "self",(char *) "checkable", NULL
42764 };
42765
42766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42773 if (!SWIG_IsOK(ecode2)) {
42774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42775 }
42776 arg2 = static_cast< bool >(val2);
42777 {
42778 PyThreadState* __tstate = wxPyBeginAllowThreads();
42779 (arg1)->SetCheckable(arg2);
42780 wxPyEndAllowThreads(__tstate);
42781 if (PyErr_Occurred()) SWIG_fail;
42782 }
42783 resultobj = SWIG_Py_Void();
42784 return resultobj;
42785 fail:
42786 return NULL;
42787 }
42788
42789
42790 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42791 PyObject *resultobj = 0;
42792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42793 bool result;
42794 void *argp1 = 0 ;
42795 int res1 = 0 ;
42796 PyObject *swig_obj[1] ;
42797
42798 if (!args) SWIG_fail;
42799 swig_obj[0] = args;
42800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42801 if (!SWIG_IsOK(res1)) {
42802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42803 }
42804 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42805 {
42806 PyThreadState* __tstate = wxPyBeginAllowThreads();
42807 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42808 wxPyEndAllowThreads(__tstate);
42809 if (PyErr_Occurred()) SWIG_fail;
42810 }
42811 {
42812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42813 }
42814 return resultobj;
42815 fail:
42816 return NULL;
42817 }
42818
42819
42820 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42821 PyObject *resultobj = 0;
42822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42823 bool result;
42824 void *argp1 = 0 ;
42825 int res1 = 0 ;
42826 PyObject *swig_obj[1] ;
42827
42828 if (!args) SWIG_fail;
42829 swig_obj[0] = args;
42830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42831 if (!SWIG_IsOK(res1)) {
42832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42833 }
42834 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42835 {
42836 PyThreadState* __tstate = wxPyBeginAllowThreads();
42837 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42838 wxPyEndAllowThreads(__tstate);
42839 if (PyErr_Occurred()) SWIG_fail;
42840 }
42841 {
42842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42843 }
42844 return resultobj;
42845 fail:
42846 return NULL;
42847 }
42848
42849
42850 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42851 PyObject *resultobj = 0;
42852 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42853 wxMenu *arg2 = (wxMenu *) 0 ;
42854 void *argp1 = 0 ;
42855 int res1 = 0 ;
42856 void *argp2 = 0 ;
42857 int res2 = 0 ;
42858 PyObject * obj0 = 0 ;
42859 PyObject * obj1 = 0 ;
42860 char * kwnames[] = {
42861 (char *) "self",(char *) "menu", NULL
42862 };
42863
42864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42866 if (!SWIG_IsOK(res1)) {
42867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42868 }
42869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42871 if (!SWIG_IsOK(res2)) {
42872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42873 }
42874 arg2 = reinterpret_cast< wxMenu * >(argp2);
42875 {
42876 PyThreadState* __tstate = wxPyBeginAllowThreads();
42877 (arg1)->SetSubMenu(arg2);
42878 wxPyEndAllowThreads(__tstate);
42879 if (PyErr_Occurred()) SWIG_fail;
42880 }
42881 resultobj = SWIG_Py_Void();
42882 return resultobj;
42883 fail:
42884 return NULL;
42885 }
42886
42887
42888 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42889 PyObject *resultobj = 0;
42890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42891 wxMenu *result = 0 ;
42892 void *argp1 = 0 ;
42893 int res1 = 0 ;
42894 PyObject *swig_obj[1] ;
42895
42896 if (!args) SWIG_fail;
42897 swig_obj[0] = args;
42898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42899 if (!SWIG_IsOK(res1)) {
42900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42901 }
42902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42903 {
42904 PyThreadState* __tstate = wxPyBeginAllowThreads();
42905 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42906 wxPyEndAllowThreads(__tstate);
42907 if (PyErr_Occurred()) SWIG_fail;
42908 }
42909 {
42910 resultobj = wxPyMake_wxObject(result, 0);
42911 }
42912 return resultobj;
42913 fail:
42914 return NULL;
42915 }
42916
42917
42918 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42919 PyObject *resultobj = 0;
42920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42921 bool arg2 = (bool) true ;
42922 void *argp1 = 0 ;
42923 int res1 = 0 ;
42924 bool val2 ;
42925 int ecode2 = 0 ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 char * kwnames[] = {
42929 (char *) "self",(char *) "enable", NULL
42930 };
42931
42932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42934 if (!SWIG_IsOK(res1)) {
42935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42936 }
42937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42938 if (obj1) {
42939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42940 if (!SWIG_IsOK(ecode2)) {
42941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42942 }
42943 arg2 = static_cast< bool >(val2);
42944 }
42945 {
42946 PyThreadState* __tstate = wxPyBeginAllowThreads();
42947 (arg1)->Enable(arg2);
42948 wxPyEndAllowThreads(__tstate);
42949 if (PyErr_Occurred()) SWIG_fail;
42950 }
42951 resultobj = SWIG_Py_Void();
42952 return resultobj;
42953 fail:
42954 return NULL;
42955 }
42956
42957
42958 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42959 PyObject *resultobj = 0;
42960 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42961 bool result;
42962 void *argp1 = 0 ;
42963 int res1 = 0 ;
42964 PyObject *swig_obj[1] ;
42965
42966 if (!args) SWIG_fail;
42967 swig_obj[0] = args;
42968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42969 if (!SWIG_IsOK(res1)) {
42970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42971 }
42972 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 {
42980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42981 }
42982 return resultobj;
42983 fail:
42984 return NULL;
42985 }
42986
42987
42988 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42989 PyObject *resultobj = 0;
42990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42991 bool arg2 = (bool) true ;
42992 void *argp1 = 0 ;
42993 int res1 = 0 ;
42994 bool val2 ;
42995 int ecode2 = 0 ;
42996 PyObject * obj0 = 0 ;
42997 PyObject * obj1 = 0 ;
42998 char * kwnames[] = {
42999 (char *) "self",(char *) "check", NULL
43000 };
43001
43002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43004 if (!SWIG_IsOK(res1)) {
43005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43006 }
43007 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43008 if (obj1) {
43009 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43010 if (!SWIG_IsOK(ecode2)) {
43011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43012 }
43013 arg2 = static_cast< bool >(val2);
43014 }
43015 {
43016 PyThreadState* __tstate = wxPyBeginAllowThreads();
43017 (arg1)->Check(arg2);
43018 wxPyEndAllowThreads(__tstate);
43019 if (PyErr_Occurred()) SWIG_fail;
43020 }
43021 resultobj = SWIG_Py_Void();
43022 return resultobj;
43023 fail:
43024 return NULL;
43025 }
43026
43027
43028 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43029 PyObject *resultobj = 0;
43030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43031 bool result;
43032 void *argp1 = 0 ;
43033 int res1 = 0 ;
43034 PyObject *swig_obj[1] ;
43035
43036 if (!args) SWIG_fail;
43037 swig_obj[0] = args;
43038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43039 if (!SWIG_IsOK(res1)) {
43040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43041 }
43042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 {
43050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43059 PyObject *resultobj = 0;
43060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43061 void *argp1 = 0 ;
43062 int res1 = 0 ;
43063 PyObject *swig_obj[1] ;
43064
43065 if (!args) SWIG_fail;
43066 swig_obj[0] = args;
43067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43068 if (!SWIG_IsOK(res1)) {
43069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43070 }
43071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43072 {
43073 PyThreadState* __tstate = wxPyBeginAllowThreads();
43074 (arg1)->Toggle();
43075 wxPyEndAllowThreads(__tstate);
43076 if (PyErr_Occurred()) SWIG_fail;
43077 }
43078 resultobj = SWIG_Py_Void();
43079 return resultobj;
43080 fail:
43081 return NULL;
43082 }
43083
43084
43085 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43086 PyObject *resultobj = 0;
43087 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43088 wxString *arg2 = 0 ;
43089 void *argp1 = 0 ;
43090 int res1 = 0 ;
43091 bool temp2 = false ;
43092 PyObject * obj0 = 0 ;
43093 PyObject * obj1 = 0 ;
43094 char * kwnames[] = {
43095 (char *) "self",(char *) "str", NULL
43096 };
43097
43098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43100 if (!SWIG_IsOK(res1)) {
43101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43102 }
43103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43104 {
43105 arg2 = wxString_in_helper(obj1);
43106 if (arg2 == NULL) SWIG_fail;
43107 temp2 = true;
43108 }
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 (arg1)->SetHelp((wxString const &)*arg2);
43112 wxPyEndAllowThreads(__tstate);
43113 if (PyErr_Occurred()) SWIG_fail;
43114 }
43115 resultobj = SWIG_Py_Void();
43116 {
43117 if (temp2)
43118 delete arg2;
43119 }
43120 return resultobj;
43121 fail:
43122 {
43123 if (temp2)
43124 delete arg2;
43125 }
43126 return NULL;
43127 }
43128
43129
43130 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43131 PyObject *resultobj = 0;
43132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43133 wxString *result = 0 ;
43134 void *argp1 = 0 ;
43135 int res1 = 0 ;
43136 PyObject *swig_obj[1] ;
43137
43138 if (!args) SWIG_fail;
43139 swig_obj[0] = args;
43140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43141 if (!SWIG_IsOK(res1)) {
43142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43143 }
43144 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 {
43148 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43149 result = (wxString *) &_result_ref;
43150 }
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 {
43155 #if wxUSE_UNICODE
43156 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43157 #else
43158 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43159 #endif
43160 }
43161 return resultobj;
43162 fail:
43163 return NULL;
43164 }
43165
43166
43167 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43168 PyObject *resultobj = 0;
43169 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43170 wxAcceleratorEntry *result = 0 ;
43171 void *argp1 = 0 ;
43172 int res1 = 0 ;
43173 PyObject *swig_obj[1] ;
43174
43175 if (!args) SWIG_fail;
43176 swig_obj[0] = args;
43177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43178 if (!SWIG_IsOK(res1)) {
43179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43180 }
43181 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43182 {
43183 PyThreadState* __tstate = wxPyBeginAllowThreads();
43184 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43185 wxPyEndAllowThreads(__tstate);
43186 if (PyErr_Occurred()) SWIG_fail;
43187 }
43188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43189 return resultobj;
43190 fail:
43191 return NULL;
43192 }
43193
43194
43195 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43196 PyObject *resultobj = 0;
43197 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43198 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43199 void *argp1 = 0 ;
43200 int res1 = 0 ;
43201 void *argp2 = 0 ;
43202 int res2 = 0 ;
43203 PyObject * obj0 = 0 ;
43204 PyObject * obj1 = 0 ;
43205 char * kwnames[] = {
43206 (char *) "self",(char *) "accel", NULL
43207 };
43208
43209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43211 if (!SWIG_IsOK(res1)) {
43212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43213 }
43214 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43215 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43216 if (!SWIG_IsOK(res2)) {
43217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43218 }
43219 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43220 {
43221 PyThreadState* __tstate = wxPyBeginAllowThreads();
43222 (arg1)->SetAccel(arg2);
43223 wxPyEndAllowThreads(__tstate);
43224 if (PyErr_Occurred()) SWIG_fail;
43225 }
43226 resultobj = SWIG_Py_Void();
43227 return resultobj;
43228 fail:
43229 return NULL;
43230 }
43231
43232
43233 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43234 PyObject *resultobj = 0;
43235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43236 wxBitmap *arg2 = 0 ;
43237 void *argp1 = 0 ;
43238 int res1 = 0 ;
43239 void *argp2 = 0 ;
43240 int res2 = 0 ;
43241 PyObject * obj0 = 0 ;
43242 PyObject * obj1 = 0 ;
43243 char * kwnames[] = {
43244 (char *) "self",(char *) "bitmap", NULL
43245 };
43246
43247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43249 if (!SWIG_IsOK(res1)) {
43250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43251 }
43252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43254 if (!SWIG_IsOK(res2)) {
43255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43256 }
43257 if (!argp2) {
43258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43259 }
43260 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43261 {
43262 PyThreadState* __tstate = wxPyBeginAllowThreads();
43263 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 resultobj = SWIG_Py_Void();
43268 return resultobj;
43269 fail:
43270 return NULL;
43271 }
43272
43273
43274 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43275 PyObject *resultobj = 0;
43276 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43277 wxBitmap *result = 0 ;
43278 void *argp1 = 0 ;
43279 int res1 = 0 ;
43280 PyObject *swig_obj[1] ;
43281
43282 if (!args) SWIG_fail;
43283 swig_obj[0] = args;
43284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43285 if (!SWIG_IsOK(res1)) {
43286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43287 }
43288 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43289 {
43290 PyThreadState* __tstate = wxPyBeginAllowThreads();
43291 {
43292 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43293 result = (wxBitmap *) &_result_ref;
43294 }
43295 wxPyEndAllowThreads(__tstate);
43296 if (PyErr_Occurred()) SWIG_fail;
43297 }
43298 {
43299 wxBitmap* resultptr = new wxBitmap(*result);
43300 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43301 }
43302 return resultobj;
43303 fail:
43304 return NULL;
43305 }
43306
43307
43308 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43309 PyObject *resultobj = 0;
43310 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43311 wxFont *arg2 = 0 ;
43312 void *argp1 = 0 ;
43313 int res1 = 0 ;
43314 void *argp2 = 0 ;
43315 int res2 = 0 ;
43316 PyObject * obj0 = 0 ;
43317 PyObject * obj1 = 0 ;
43318 char * kwnames[] = {
43319 (char *) "self",(char *) "font", NULL
43320 };
43321
43322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43324 if (!SWIG_IsOK(res1)) {
43325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43326 }
43327 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43329 if (!SWIG_IsOK(res2)) {
43330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43331 }
43332 if (!argp2) {
43333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43334 }
43335 arg2 = reinterpret_cast< wxFont * >(argp2);
43336 {
43337 PyThreadState* __tstate = wxPyBeginAllowThreads();
43338 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43339 wxPyEndAllowThreads(__tstate);
43340 if (PyErr_Occurred()) SWIG_fail;
43341 }
43342 resultobj = SWIG_Py_Void();
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43350 PyObject *resultobj = 0;
43351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43352 wxFont result;
43353 void *argp1 = 0 ;
43354 int res1 = 0 ;
43355 PyObject *swig_obj[1] ;
43356
43357 if (!args) SWIG_fail;
43358 swig_obj[0] = args;
43359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43360 if (!SWIG_IsOK(res1)) {
43361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43362 }
43363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43364 {
43365 PyThreadState* __tstate = wxPyBeginAllowThreads();
43366 result = wxMenuItem_GetFont(arg1);
43367 wxPyEndAllowThreads(__tstate);
43368 if (PyErr_Occurred()) SWIG_fail;
43369 }
43370 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43371 return resultobj;
43372 fail:
43373 return NULL;
43374 }
43375
43376
43377 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43378 PyObject *resultobj = 0;
43379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43380 wxColour *arg2 = 0 ;
43381 void *argp1 = 0 ;
43382 int res1 = 0 ;
43383 wxColour temp2 ;
43384 PyObject * obj0 = 0 ;
43385 PyObject * obj1 = 0 ;
43386 char * kwnames[] = {
43387 (char *) "self",(char *) "colText", NULL
43388 };
43389
43390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43392 if (!SWIG_IsOK(res1)) {
43393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43394 }
43395 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43396 {
43397 arg2 = &temp2;
43398 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43399 }
43400 {
43401 PyThreadState* __tstate = wxPyBeginAllowThreads();
43402 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43403 wxPyEndAllowThreads(__tstate);
43404 if (PyErr_Occurred()) SWIG_fail;
43405 }
43406 resultobj = SWIG_Py_Void();
43407 return resultobj;
43408 fail:
43409 return NULL;
43410 }
43411
43412
43413 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43414 PyObject *resultobj = 0;
43415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43416 wxColour result;
43417 void *argp1 = 0 ;
43418 int res1 = 0 ;
43419 PyObject *swig_obj[1] ;
43420
43421 if (!args) SWIG_fail;
43422 swig_obj[0] = args;
43423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43424 if (!SWIG_IsOK(res1)) {
43425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43426 }
43427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43428 {
43429 PyThreadState* __tstate = wxPyBeginAllowThreads();
43430 result = wxMenuItem_GetTextColour(arg1);
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43435 return resultobj;
43436 fail:
43437 return NULL;
43438 }
43439
43440
43441 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43442 PyObject *resultobj = 0;
43443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43444 wxColour *arg2 = 0 ;
43445 void *argp1 = 0 ;
43446 int res1 = 0 ;
43447 wxColour temp2 ;
43448 PyObject * obj0 = 0 ;
43449 PyObject * obj1 = 0 ;
43450 char * kwnames[] = {
43451 (char *) "self",(char *) "colBack", NULL
43452 };
43453
43454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43456 if (!SWIG_IsOK(res1)) {
43457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43458 }
43459 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43460 {
43461 arg2 = &temp2;
43462 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43463 }
43464 {
43465 PyThreadState* __tstate = wxPyBeginAllowThreads();
43466 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43467 wxPyEndAllowThreads(__tstate);
43468 if (PyErr_Occurred()) SWIG_fail;
43469 }
43470 resultobj = SWIG_Py_Void();
43471 return resultobj;
43472 fail:
43473 return NULL;
43474 }
43475
43476
43477 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43478 PyObject *resultobj = 0;
43479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43480 wxColour result;
43481 void *argp1 = 0 ;
43482 int res1 = 0 ;
43483 PyObject *swig_obj[1] ;
43484
43485 if (!args) SWIG_fail;
43486 swig_obj[0] = args;
43487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43488 if (!SWIG_IsOK(res1)) {
43489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43490 }
43491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43492 {
43493 PyThreadState* __tstate = wxPyBeginAllowThreads();
43494 result = wxMenuItem_GetBackgroundColour(arg1);
43495 wxPyEndAllowThreads(__tstate);
43496 if (PyErr_Occurred()) SWIG_fail;
43497 }
43498 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43499 return resultobj;
43500 fail:
43501 return NULL;
43502 }
43503
43504
43505 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43506 PyObject *resultobj = 0;
43507 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43508 wxBitmap *arg2 = 0 ;
43509 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43510 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43511 void *argp1 = 0 ;
43512 int res1 = 0 ;
43513 void *argp2 = 0 ;
43514 int res2 = 0 ;
43515 void *argp3 = 0 ;
43516 int res3 = 0 ;
43517 PyObject * obj0 = 0 ;
43518 PyObject * obj1 = 0 ;
43519 PyObject * obj2 = 0 ;
43520 char * kwnames[] = {
43521 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43522 };
43523
43524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43526 if (!SWIG_IsOK(res1)) {
43527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43528 }
43529 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43531 if (!SWIG_IsOK(res2)) {
43532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43533 }
43534 if (!argp2) {
43535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43536 }
43537 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43538 if (obj2) {
43539 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43540 if (!SWIG_IsOK(res3)) {
43541 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43542 }
43543 if (!argp3) {
43544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43545 }
43546 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43547 }
43548 {
43549 PyThreadState* __tstate = wxPyBeginAllowThreads();
43550 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43551 wxPyEndAllowThreads(__tstate);
43552 if (PyErr_Occurred()) SWIG_fail;
43553 }
43554 resultobj = SWIG_Py_Void();
43555 return resultobj;
43556 fail:
43557 return NULL;
43558 }
43559
43560
43561 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43562 PyObject *resultobj = 0;
43563 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43564 wxBitmap *arg2 = 0 ;
43565 void *argp1 = 0 ;
43566 int res1 = 0 ;
43567 void *argp2 = 0 ;
43568 int res2 = 0 ;
43569 PyObject * obj0 = 0 ;
43570 PyObject * obj1 = 0 ;
43571 char * kwnames[] = {
43572 (char *) "self",(char *) "bmpDisabled", NULL
43573 };
43574
43575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43577 if (!SWIG_IsOK(res1)) {
43578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43579 }
43580 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43582 if (!SWIG_IsOK(res2)) {
43583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43584 }
43585 if (!argp2) {
43586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43587 }
43588 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43592 wxPyEndAllowThreads(__tstate);
43593 if (PyErr_Occurred()) SWIG_fail;
43594 }
43595 resultobj = SWIG_Py_Void();
43596 return resultobj;
43597 fail:
43598 return NULL;
43599 }
43600
43601
43602 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43603 PyObject *resultobj = 0;
43604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43605 wxBitmap *result = 0 ;
43606 void *argp1 = 0 ;
43607 int res1 = 0 ;
43608 PyObject *swig_obj[1] ;
43609
43610 if (!args) SWIG_fail;
43611 swig_obj[0] = args;
43612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43613 if (!SWIG_IsOK(res1)) {
43614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43615 }
43616 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43617 {
43618 PyThreadState* __tstate = wxPyBeginAllowThreads();
43619 {
43620 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43621 result = (wxBitmap *) &_result_ref;
43622 }
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 {
43627 wxBitmap* resultptr = new wxBitmap(*result);
43628 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43629 }
43630 return resultobj;
43631 fail:
43632 return NULL;
43633 }
43634
43635
43636 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43637 PyObject *resultobj = 0;
43638 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43639 int arg2 ;
43640 void *argp1 = 0 ;
43641 int res1 = 0 ;
43642 int val2 ;
43643 int ecode2 = 0 ;
43644 PyObject * obj0 = 0 ;
43645 PyObject * obj1 = 0 ;
43646 char * kwnames[] = {
43647 (char *) "self",(char *) "nWidth", NULL
43648 };
43649
43650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43652 if (!SWIG_IsOK(res1)) {
43653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43654 }
43655 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43656 ecode2 = SWIG_AsVal_int(obj1, &val2);
43657 if (!SWIG_IsOK(ecode2)) {
43658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43659 }
43660 arg2 = static_cast< int >(val2);
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 wxMenuItem_SetMarginWidth(arg1,arg2);
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 resultobj = SWIG_Py_Void();
43668 return resultobj;
43669 fail:
43670 return NULL;
43671 }
43672
43673
43674 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43675 PyObject *resultobj = 0;
43676 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43677 int result;
43678 void *argp1 = 0 ;
43679 int res1 = 0 ;
43680 PyObject *swig_obj[1] ;
43681
43682 if (!args) SWIG_fail;
43683 swig_obj[0] = args;
43684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43685 if (!SWIG_IsOK(res1)) {
43686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43687 }
43688 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43689 {
43690 PyThreadState* __tstate = wxPyBeginAllowThreads();
43691 result = (int)wxMenuItem_GetMarginWidth(arg1);
43692 wxPyEndAllowThreads(__tstate);
43693 if (PyErr_Occurred()) SWIG_fail;
43694 }
43695 resultobj = SWIG_From_int(static_cast< int >(result));
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43703 PyObject *resultobj = 0;
43704 int result;
43705
43706 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43707 {
43708 PyThreadState* __tstate = wxPyBeginAllowThreads();
43709 result = (int)wxMenuItem_GetDefaultMarginWidth();
43710 wxPyEndAllowThreads(__tstate);
43711 if (PyErr_Occurred()) SWIG_fail;
43712 }
43713 resultobj = SWIG_From_int(static_cast< int >(result));
43714 return resultobj;
43715 fail:
43716 return NULL;
43717 }
43718
43719
43720 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43721 PyObject *resultobj = 0;
43722 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43723 bool result;
43724 void *argp1 = 0 ;
43725 int res1 = 0 ;
43726 PyObject *swig_obj[1] ;
43727
43728 if (!args) SWIG_fail;
43729 swig_obj[0] = args;
43730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43731 if (!SWIG_IsOK(res1)) {
43732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43733 }
43734 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43735 {
43736 PyThreadState* __tstate = wxPyBeginAllowThreads();
43737 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 {
43742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43743 }
43744 return resultobj;
43745 fail:
43746 return NULL;
43747 }
43748
43749
43750 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43751 PyObject *resultobj = 0;
43752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43753 bool arg2 = (bool) true ;
43754 void *argp1 = 0 ;
43755 int res1 = 0 ;
43756 bool val2 ;
43757 int ecode2 = 0 ;
43758 PyObject * obj0 = 0 ;
43759 PyObject * obj1 = 0 ;
43760 char * kwnames[] = {
43761 (char *) "self",(char *) "ownerDrawn", NULL
43762 };
43763
43764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43766 if (!SWIG_IsOK(res1)) {
43767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43768 }
43769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43770 if (obj1) {
43771 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43772 if (!SWIG_IsOK(ecode2)) {
43773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43774 }
43775 arg2 = static_cast< bool >(val2);
43776 }
43777 {
43778 PyThreadState* __tstate = wxPyBeginAllowThreads();
43779 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43780 wxPyEndAllowThreads(__tstate);
43781 if (PyErr_Occurred()) SWIG_fail;
43782 }
43783 resultobj = SWIG_Py_Void();
43784 return resultobj;
43785 fail:
43786 return NULL;
43787 }
43788
43789
43790 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43791 PyObject *resultobj = 0;
43792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43793 void *argp1 = 0 ;
43794 int res1 = 0 ;
43795 PyObject *swig_obj[1] ;
43796
43797 if (!args) SWIG_fail;
43798 swig_obj[0] = args;
43799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43800 if (!SWIG_IsOK(res1)) {
43801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43802 }
43803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43804 {
43805 PyThreadState* __tstate = wxPyBeginAllowThreads();
43806 wxMenuItem_ResetOwnerDrawn(arg1);
43807 wxPyEndAllowThreads(__tstate);
43808 if (PyErr_Occurred()) SWIG_fail;
43809 }
43810 resultobj = SWIG_Py_Void();
43811 return resultobj;
43812 fail:
43813 return NULL;
43814 }
43815
43816
43817 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43818 PyObject *obj;
43819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43820 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43821 return SWIG_Py_Void();
43822 }
43823
43824 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43825 return SWIG_Python_InitShadowInstance(args);
43826 }
43827
43828 SWIGINTERN int ControlNameStr_set(PyObject *) {
43829 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43830 return 1;
43831 }
43832
43833
43834 SWIGINTERN PyObject *ControlNameStr_get(void) {
43835 PyObject *pyobj = 0;
43836
43837 {
43838 #if wxUSE_UNICODE
43839 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43840 #else
43841 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43842 #endif
43843 }
43844 return pyobj;
43845 }
43846
43847
43848 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43849 PyObject *resultobj = 0;
43850 wxWindow *arg1 = (wxWindow *) 0 ;
43851 int arg2 = (int) -1 ;
43852 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43853 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43854 wxSize const &arg4_defvalue = wxDefaultSize ;
43855 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43856 long arg5 = (long) 0 ;
43857 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43858 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43859 wxString const &arg7_defvalue = wxPyControlNameStr ;
43860 wxString *arg7 = (wxString *) &arg7_defvalue ;
43861 wxControl *result = 0 ;
43862 void *argp1 = 0 ;
43863 int res1 = 0 ;
43864 int val2 ;
43865 int ecode2 = 0 ;
43866 wxPoint temp3 ;
43867 wxSize temp4 ;
43868 long val5 ;
43869 int ecode5 = 0 ;
43870 void *argp6 = 0 ;
43871 int res6 = 0 ;
43872 bool temp7 = false ;
43873 PyObject * obj0 = 0 ;
43874 PyObject * obj1 = 0 ;
43875 PyObject * obj2 = 0 ;
43876 PyObject * obj3 = 0 ;
43877 PyObject * obj4 = 0 ;
43878 PyObject * obj5 = 0 ;
43879 PyObject * obj6 = 0 ;
43880 char * kwnames[] = {
43881 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43882 };
43883
43884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43886 if (!SWIG_IsOK(res1)) {
43887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43888 }
43889 arg1 = reinterpret_cast< wxWindow * >(argp1);
43890 if (obj1) {
43891 ecode2 = SWIG_AsVal_int(obj1, &val2);
43892 if (!SWIG_IsOK(ecode2)) {
43893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43894 }
43895 arg2 = static_cast< int >(val2);
43896 }
43897 if (obj2) {
43898 {
43899 arg3 = &temp3;
43900 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43901 }
43902 }
43903 if (obj3) {
43904 {
43905 arg4 = &temp4;
43906 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43907 }
43908 }
43909 if (obj4) {
43910 ecode5 = SWIG_AsVal_long(obj4, &val5);
43911 if (!SWIG_IsOK(ecode5)) {
43912 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43913 }
43914 arg5 = static_cast< long >(val5);
43915 }
43916 if (obj5) {
43917 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43918 if (!SWIG_IsOK(res6)) {
43919 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43920 }
43921 if (!argp6) {
43922 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43923 }
43924 arg6 = reinterpret_cast< wxValidator * >(argp6);
43925 }
43926 if (obj6) {
43927 {
43928 arg7 = wxString_in_helper(obj6);
43929 if (arg7 == NULL) SWIG_fail;
43930 temp7 = true;
43931 }
43932 }
43933 {
43934 if (!wxPyCheckForApp()) SWIG_fail;
43935 PyThreadState* __tstate = wxPyBeginAllowThreads();
43936 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43937 wxPyEndAllowThreads(__tstate);
43938 if (PyErr_Occurred()) SWIG_fail;
43939 }
43940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43941 {
43942 if (temp7)
43943 delete arg7;
43944 }
43945 return resultobj;
43946 fail:
43947 {
43948 if (temp7)
43949 delete arg7;
43950 }
43951 return NULL;
43952 }
43953
43954
43955 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43956 PyObject *resultobj = 0;
43957 wxControl *result = 0 ;
43958
43959 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43960 {
43961 if (!wxPyCheckForApp()) SWIG_fail;
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 result = (wxControl *)new wxControl();
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxControl *arg1 = (wxControl *) 0 ;
43977 wxWindow *arg2 = (wxWindow *) 0 ;
43978 int arg3 = (int) -1 ;
43979 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43980 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43981 wxSize const &arg5_defvalue = wxDefaultSize ;
43982 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43983 long arg6 = (long) 0 ;
43984 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43985 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43986 wxString const &arg8_defvalue = wxPyControlNameStr ;
43987 wxString *arg8 = (wxString *) &arg8_defvalue ;
43988 bool result;
43989 void *argp1 = 0 ;
43990 int res1 = 0 ;
43991 void *argp2 = 0 ;
43992 int res2 = 0 ;
43993 int val3 ;
43994 int ecode3 = 0 ;
43995 wxPoint temp4 ;
43996 wxSize temp5 ;
43997 long val6 ;
43998 int ecode6 = 0 ;
43999 void *argp7 = 0 ;
44000 int res7 = 0 ;
44001 bool temp8 = false ;
44002 PyObject * obj0 = 0 ;
44003 PyObject * obj1 = 0 ;
44004 PyObject * obj2 = 0 ;
44005 PyObject * obj3 = 0 ;
44006 PyObject * obj4 = 0 ;
44007 PyObject * obj5 = 0 ;
44008 PyObject * obj6 = 0 ;
44009 PyObject * obj7 = 0 ;
44010 char * kwnames[] = {
44011 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44012 };
44013
44014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44016 if (!SWIG_IsOK(res1)) {
44017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44018 }
44019 arg1 = reinterpret_cast< wxControl * >(argp1);
44020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44021 if (!SWIG_IsOK(res2)) {
44022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44023 }
44024 arg2 = reinterpret_cast< wxWindow * >(argp2);
44025 if (obj2) {
44026 ecode3 = SWIG_AsVal_int(obj2, &val3);
44027 if (!SWIG_IsOK(ecode3)) {
44028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44029 }
44030 arg3 = static_cast< int >(val3);
44031 }
44032 if (obj3) {
44033 {
44034 arg4 = &temp4;
44035 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44036 }
44037 }
44038 if (obj4) {
44039 {
44040 arg5 = &temp5;
44041 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44042 }
44043 }
44044 if (obj5) {
44045 ecode6 = SWIG_AsVal_long(obj5, &val6);
44046 if (!SWIG_IsOK(ecode6)) {
44047 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44048 }
44049 arg6 = static_cast< long >(val6);
44050 }
44051 if (obj6) {
44052 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44053 if (!SWIG_IsOK(res7)) {
44054 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44055 }
44056 if (!argp7) {
44057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44058 }
44059 arg7 = reinterpret_cast< wxValidator * >(argp7);
44060 }
44061 if (obj7) {
44062 {
44063 arg8 = wxString_in_helper(obj7);
44064 if (arg8 == NULL) SWIG_fail;
44065 temp8 = true;
44066 }
44067 }
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 {
44075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44076 }
44077 {
44078 if (temp8)
44079 delete arg8;
44080 }
44081 return resultobj;
44082 fail:
44083 {
44084 if (temp8)
44085 delete arg8;
44086 }
44087 return NULL;
44088 }
44089
44090
44091 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44092 PyObject *resultobj = 0;
44093 wxControl *arg1 = (wxControl *) 0 ;
44094 wxCommandEvent *arg2 = 0 ;
44095 void *argp1 = 0 ;
44096 int res1 = 0 ;
44097 void *argp2 = 0 ;
44098 int res2 = 0 ;
44099 PyObject * obj0 = 0 ;
44100 PyObject * obj1 = 0 ;
44101 char * kwnames[] = {
44102 (char *) "self",(char *) "event", NULL
44103 };
44104
44105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44109 }
44110 arg1 = reinterpret_cast< wxControl * >(argp1);
44111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44112 if (!SWIG_IsOK(res2)) {
44113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44114 }
44115 if (!argp2) {
44116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44117 }
44118 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44119 {
44120 PyThreadState* __tstate = wxPyBeginAllowThreads();
44121 (arg1)->Command(*arg2);
44122 wxPyEndAllowThreads(__tstate);
44123 if (PyErr_Occurred()) SWIG_fail;
44124 }
44125 resultobj = SWIG_Py_Void();
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44133 PyObject *resultobj = 0;
44134 wxControl *arg1 = (wxControl *) 0 ;
44135 wxString result;
44136 void *argp1 = 0 ;
44137 int res1 = 0 ;
44138 PyObject *swig_obj[1] ;
44139
44140 if (!args) SWIG_fail;
44141 swig_obj[0] = args;
44142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44143 if (!SWIG_IsOK(res1)) {
44144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44145 }
44146 arg1 = reinterpret_cast< wxControl * >(argp1);
44147 {
44148 PyThreadState* __tstate = wxPyBeginAllowThreads();
44149 result = (arg1)->GetLabel();
44150 wxPyEndAllowThreads(__tstate);
44151 if (PyErr_Occurred()) SWIG_fail;
44152 }
44153 {
44154 #if wxUSE_UNICODE
44155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44156 #else
44157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44158 #endif
44159 }
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44167 PyObject *resultobj = 0;
44168 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44169 SwigValueWrapper<wxVisualAttributes > result;
44170 int val1 ;
44171 int ecode1 = 0 ;
44172 PyObject * obj0 = 0 ;
44173 char * kwnames[] = {
44174 (char *) "variant", NULL
44175 };
44176
44177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44178 if (obj0) {
44179 ecode1 = SWIG_AsVal_int(obj0, &val1);
44180 if (!SWIG_IsOK(ecode1)) {
44181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44182 }
44183 arg1 = static_cast< wxWindowVariant >(val1);
44184 }
44185 {
44186 if (!wxPyCheckForApp()) SWIG_fail;
44187 PyThreadState* __tstate = wxPyBeginAllowThreads();
44188 result = wxControl::GetClassDefaultAttributes(arg1);
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44193 return resultobj;
44194 fail:
44195 return NULL;
44196 }
44197
44198
44199 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44200 PyObject *obj;
44201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44202 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44203 return SWIG_Py_Void();
44204 }
44205
44206 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44207 return SWIG_Python_InitShadowInstance(args);
44208 }
44209
44210 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44211 PyObject *resultobj = 0;
44212 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44213 wxString *arg2 = 0 ;
44214 PyObject *arg3 = (PyObject *) NULL ;
44215 int result;
44216 void *argp1 = 0 ;
44217 int res1 = 0 ;
44218 bool temp2 = false ;
44219 PyObject * obj0 = 0 ;
44220 PyObject * obj1 = 0 ;
44221 PyObject * obj2 = 0 ;
44222 char * kwnames[] = {
44223 (char *) "self",(char *) "item",(char *) "clientData", NULL
44224 };
44225
44226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44228 if (!SWIG_IsOK(res1)) {
44229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44230 }
44231 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44232 {
44233 arg2 = wxString_in_helper(obj1);
44234 if (arg2 == NULL) SWIG_fail;
44235 temp2 = true;
44236 }
44237 if (obj2) {
44238 arg3 = obj2;
44239 }
44240 {
44241 PyThreadState* __tstate = wxPyBeginAllowThreads();
44242 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44243 wxPyEndAllowThreads(__tstate);
44244 if (PyErr_Occurred()) SWIG_fail;
44245 }
44246 resultobj = SWIG_From_int(static_cast< int >(result));
44247 {
44248 if (temp2)
44249 delete arg2;
44250 }
44251 return resultobj;
44252 fail:
44253 {
44254 if (temp2)
44255 delete arg2;
44256 }
44257 return NULL;
44258 }
44259
44260
44261 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44262 PyObject *resultobj = 0;
44263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44264 wxArrayString *arg2 = 0 ;
44265 void *argp1 = 0 ;
44266 int res1 = 0 ;
44267 bool temp2 = false ;
44268 PyObject * obj0 = 0 ;
44269 PyObject * obj1 = 0 ;
44270 char * kwnames[] = {
44271 (char *) "self",(char *) "strings", NULL
44272 };
44273
44274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44276 if (!SWIG_IsOK(res1)) {
44277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44278 }
44279 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44280 {
44281 if (! PySequence_Check(obj1)) {
44282 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44283 SWIG_fail;
44284 }
44285 arg2 = new wxArrayString;
44286 temp2 = true;
44287 int i, len=PySequence_Length(obj1);
44288 for (i=0; i<len; i++) {
44289 PyObject* item = PySequence_GetItem(obj1, i);
44290 wxString* s = wxString_in_helper(item);
44291 if (PyErr_Occurred()) SWIG_fail;
44292 arg2->Add(*s);
44293 delete s;
44294 Py_DECREF(item);
44295 }
44296 }
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 (arg1)->Append((wxArrayString const &)*arg2);
44300 wxPyEndAllowThreads(__tstate);
44301 if (PyErr_Occurred()) SWIG_fail;
44302 }
44303 resultobj = SWIG_Py_Void();
44304 {
44305 if (temp2) delete arg2;
44306 }
44307 return resultobj;
44308 fail:
44309 {
44310 if (temp2) delete arg2;
44311 }
44312 return NULL;
44313 }
44314
44315
44316 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44317 PyObject *resultobj = 0;
44318 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44319 wxString *arg2 = 0 ;
44320 unsigned int arg3 ;
44321 PyObject *arg4 = (PyObject *) NULL ;
44322 int result;
44323 void *argp1 = 0 ;
44324 int res1 = 0 ;
44325 bool temp2 = false ;
44326 unsigned int val3 ;
44327 int ecode3 = 0 ;
44328 PyObject * obj0 = 0 ;
44329 PyObject * obj1 = 0 ;
44330 PyObject * obj2 = 0 ;
44331 PyObject * obj3 = 0 ;
44332 char * kwnames[] = {
44333 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44334 };
44335
44336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44338 if (!SWIG_IsOK(res1)) {
44339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44340 }
44341 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44342 {
44343 arg2 = wxString_in_helper(obj1);
44344 if (arg2 == NULL) SWIG_fail;
44345 temp2 = true;
44346 }
44347 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44348 if (!SWIG_IsOK(ecode3)) {
44349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44350 }
44351 arg3 = static_cast< unsigned int >(val3);
44352 if (obj3) {
44353 arg4 = obj3;
44354 }
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_From_int(static_cast< int >(result));
44362 {
44363 if (temp2)
44364 delete arg2;
44365 }
44366 return resultobj;
44367 fail:
44368 {
44369 if (temp2)
44370 delete arg2;
44371 }
44372 return NULL;
44373 }
44374
44375
44376 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44377 PyObject *resultobj = 0;
44378 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44379 void *argp1 = 0 ;
44380 int res1 = 0 ;
44381 PyObject *swig_obj[1] ;
44382
44383 if (!args) SWIG_fail;
44384 swig_obj[0] = args;
44385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44386 if (!SWIG_IsOK(res1)) {
44387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44388 }
44389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44390 {
44391 PyThreadState* __tstate = wxPyBeginAllowThreads();
44392 (arg1)->Clear();
44393 wxPyEndAllowThreads(__tstate);
44394 if (PyErr_Occurred()) SWIG_fail;
44395 }
44396 resultobj = SWIG_Py_Void();
44397 return resultobj;
44398 fail:
44399 return NULL;
44400 }
44401
44402
44403 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44404 PyObject *resultobj = 0;
44405 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44406 unsigned int arg2 ;
44407 void *argp1 = 0 ;
44408 int res1 = 0 ;
44409 unsigned int val2 ;
44410 int ecode2 = 0 ;
44411 PyObject * obj0 = 0 ;
44412 PyObject * obj1 = 0 ;
44413 char * kwnames[] = {
44414 (char *) "self",(char *) "n", NULL
44415 };
44416
44417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44419 if (!SWIG_IsOK(res1)) {
44420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44421 }
44422 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44423 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44424 if (!SWIG_IsOK(ecode2)) {
44425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44426 }
44427 arg2 = static_cast< unsigned int >(val2);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 (arg1)->Delete(arg2);
44431 wxPyEndAllowThreads(__tstate);
44432 if (PyErr_Occurred()) SWIG_fail;
44433 }
44434 resultobj = SWIG_Py_Void();
44435 return resultobj;
44436 fail:
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44442 PyObject *resultobj = 0;
44443 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44444 unsigned int arg2 ;
44445 PyObject *result = 0 ;
44446 void *argp1 = 0 ;
44447 int res1 = 0 ;
44448 unsigned int val2 ;
44449 int ecode2 = 0 ;
44450 PyObject * obj0 = 0 ;
44451 PyObject * obj1 = 0 ;
44452 char * kwnames[] = {
44453 (char *) "self",(char *) "n", NULL
44454 };
44455
44456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44458 if (!SWIG_IsOK(res1)) {
44459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44460 }
44461 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44462 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44463 if (!SWIG_IsOK(ecode2)) {
44464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44465 }
44466 arg2 = static_cast< unsigned int >(val2);
44467 {
44468 PyThreadState* __tstate = wxPyBeginAllowThreads();
44469 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44470 wxPyEndAllowThreads(__tstate);
44471 if (PyErr_Occurred()) SWIG_fail;
44472 }
44473 resultobj = result;
44474 return resultobj;
44475 fail:
44476 return NULL;
44477 }
44478
44479
44480 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44481 PyObject *resultobj = 0;
44482 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44483 unsigned int arg2 ;
44484 PyObject *arg3 = (PyObject *) 0 ;
44485 void *argp1 = 0 ;
44486 int res1 = 0 ;
44487 unsigned int val2 ;
44488 int ecode2 = 0 ;
44489 PyObject * obj0 = 0 ;
44490 PyObject * obj1 = 0 ;
44491 PyObject * obj2 = 0 ;
44492 char * kwnames[] = {
44493 (char *) "self",(char *) "n",(char *) "clientData", NULL
44494 };
44495
44496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44498 if (!SWIG_IsOK(res1)) {
44499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44500 }
44501 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44502 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44503 if (!SWIG_IsOK(ecode2)) {
44504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44505 }
44506 arg2 = static_cast< unsigned int >(val2);
44507 arg3 = obj2;
44508 {
44509 PyThreadState* __tstate = wxPyBeginAllowThreads();
44510 wxItemContainer_SetClientData(arg1,arg2,arg3);
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 resultobj = SWIG_Py_Void();
44515 return resultobj;
44516 fail:
44517 return NULL;
44518 }
44519
44520
44521 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44522 PyObject *resultobj = 0;
44523 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44524 unsigned int result;
44525 void *argp1 = 0 ;
44526 int res1 = 0 ;
44527 PyObject *swig_obj[1] ;
44528
44529 if (!args) SWIG_fail;
44530 swig_obj[0] = args;
44531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44534 }
44535 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44536 {
44537 PyThreadState* __tstate = wxPyBeginAllowThreads();
44538 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44539 wxPyEndAllowThreads(__tstate);
44540 if (PyErr_Occurred()) SWIG_fail;
44541 }
44542 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44543 return resultobj;
44544 fail:
44545 return NULL;
44546 }
44547
44548
44549 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44550 PyObject *resultobj = 0;
44551 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44552 bool result;
44553 void *argp1 = 0 ;
44554 int res1 = 0 ;
44555 PyObject *swig_obj[1] ;
44556
44557 if (!args) SWIG_fail;
44558 swig_obj[0] = args;
44559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44560 if (!SWIG_IsOK(res1)) {
44561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44562 }
44563 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44564 {
44565 PyThreadState* __tstate = wxPyBeginAllowThreads();
44566 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 {
44571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44572 }
44573 return resultobj;
44574 fail:
44575 return NULL;
44576 }
44577
44578
44579 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44580 PyObject *resultobj = 0;
44581 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44582 unsigned int arg2 ;
44583 wxString result;
44584 void *argp1 = 0 ;
44585 int res1 = 0 ;
44586 unsigned int val2 ;
44587 int ecode2 = 0 ;
44588 PyObject * obj0 = 0 ;
44589 PyObject * obj1 = 0 ;
44590 char * kwnames[] = {
44591 (char *) "self",(char *) "n", NULL
44592 };
44593
44594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44596 if (!SWIG_IsOK(res1)) {
44597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44598 }
44599 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44600 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44601 if (!SWIG_IsOK(ecode2)) {
44602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44603 }
44604 arg2 = static_cast< unsigned int >(val2);
44605 {
44606 PyThreadState* __tstate = wxPyBeginAllowThreads();
44607 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44608 wxPyEndAllowThreads(__tstate);
44609 if (PyErr_Occurred()) SWIG_fail;
44610 }
44611 {
44612 #if wxUSE_UNICODE
44613 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44614 #else
44615 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44616 #endif
44617 }
44618 return resultobj;
44619 fail:
44620 return NULL;
44621 }
44622
44623
44624 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44625 PyObject *resultobj = 0;
44626 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44627 wxArrayString result;
44628 void *argp1 = 0 ;
44629 int res1 = 0 ;
44630 PyObject *swig_obj[1] ;
44631
44632 if (!args) SWIG_fail;
44633 swig_obj[0] = args;
44634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44635 if (!SWIG_IsOK(res1)) {
44636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44637 }
44638 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 result = ((wxItemContainer const *)arg1)->GetStrings();
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 {
44646 resultobj = wxArrayString2PyList_helper(result);
44647 }
44648 return resultobj;
44649 fail:
44650 return NULL;
44651 }
44652
44653
44654 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44655 PyObject *resultobj = 0;
44656 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44657 unsigned int arg2 ;
44658 wxString *arg3 = 0 ;
44659 void *argp1 = 0 ;
44660 int res1 = 0 ;
44661 unsigned int val2 ;
44662 int ecode2 = 0 ;
44663 bool temp3 = false ;
44664 PyObject * obj0 = 0 ;
44665 PyObject * obj1 = 0 ;
44666 PyObject * obj2 = 0 ;
44667 char * kwnames[] = {
44668 (char *) "self",(char *) "n",(char *) "s", NULL
44669 };
44670
44671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44673 if (!SWIG_IsOK(res1)) {
44674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44675 }
44676 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44677 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44678 if (!SWIG_IsOK(ecode2)) {
44679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44680 }
44681 arg2 = static_cast< unsigned int >(val2);
44682 {
44683 arg3 = wxString_in_helper(obj2);
44684 if (arg3 == NULL) SWIG_fail;
44685 temp3 = true;
44686 }
44687 {
44688 PyThreadState* __tstate = wxPyBeginAllowThreads();
44689 (arg1)->SetString(arg2,(wxString const &)*arg3);
44690 wxPyEndAllowThreads(__tstate);
44691 if (PyErr_Occurred()) SWIG_fail;
44692 }
44693 resultobj = SWIG_Py_Void();
44694 {
44695 if (temp3)
44696 delete arg3;
44697 }
44698 return resultobj;
44699 fail:
44700 {
44701 if (temp3)
44702 delete arg3;
44703 }
44704 return NULL;
44705 }
44706
44707
44708 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44709 PyObject *resultobj = 0;
44710 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44711 wxString *arg2 = 0 ;
44712 int result;
44713 void *argp1 = 0 ;
44714 int res1 = 0 ;
44715 bool temp2 = false ;
44716 PyObject * obj0 = 0 ;
44717 PyObject * obj1 = 0 ;
44718 char * kwnames[] = {
44719 (char *) "self",(char *) "s", NULL
44720 };
44721
44722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44724 if (!SWIG_IsOK(res1)) {
44725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44726 }
44727 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44728 {
44729 arg2 = wxString_in_helper(obj1);
44730 if (arg2 == NULL) SWIG_fail;
44731 temp2 = true;
44732 }
44733 {
44734 PyThreadState* __tstate = wxPyBeginAllowThreads();
44735 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44736 wxPyEndAllowThreads(__tstate);
44737 if (PyErr_Occurred()) SWIG_fail;
44738 }
44739 resultobj = SWIG_From_int(static_cast< int >(result));
44740 {
44741 if (temp2)
44742 delete arg2;
44743 }
44744 return resultobj;
44745 fail:
44746 {
44747 if (temp2)
44748 delete arg2;
44749 }
44750 return NULL;
44751 }
44752
44753
44754 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44755 PyObject *resultobj = 0;
44756 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44757 int arg2 ;
44758 void *argp1 = 0 ;
44759 int res1 = 0 ;
44760 int val2 ;
44761 int ecode2 = 0 ;
44762 PyObject * obj0 = 0 ;
44763 PyObject * obj1 = 0 ;
44764 char * kwnames[] = {
44765 (char *) "self",(char *) "n", NULL
44766 };
44767
44768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44770 if (!SWIG_IsOK(res1)) {
44771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44772 }
44773 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44774 ecode2 = SWIG_AsVal_int(obj1, &val2);
44775 if (!SWIG_IsOK(ecode2)) {
44776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44777 }
44778 arg2 = static_cast< int >(val2);
44779 {
44780 PyThreadState* __tstate = wxPyBeginAllowThreads();
44781 (arg1)->SetSelection(arg2);
44782 wxPyEndAllowThreads(__tstate);
44783 if (PyErr_Occurred()) SWIG_fail;
44784 }
44785 resultobj = SWIG_Py_Void();
44786 return resultobj;
44787 fail:
44788 return NULL;
44789 }
44790
44791
44792 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44793 PyObject *resultobj = 0;
44794 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44795 int result;
44796 void *argp1 = 0 ;
44797 int res1 = 0 ;
44798 PyObject *swig_obj[1] ;
44799
44800 if (!args) SWIG_fail;
44801 swig_obj[0] = args;
44802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44803 if (!SWIG_IsOK(res1)) {
44804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44805 }
44806 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44807 {
44808 PyThreadState* __tstate = wxPyBeginAllowThreads();
44809 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44810 wxPyEndAllowThreads(__tstate);
44811 if (PyErr_Occurred()) SWIG_fail;
44812 }
44813 resultobj = SWIG_From_int(static_cast< int >(result));
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44821 PyObject *resultobj = 0;
44822 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44823 wxString *arg2 = 0 ;
44824 bool result;
44825 void *argp1 = 0 ;
44826 int res1 = 0 ;
44827 bool temp2 = false ;
44828 PyObject * obj0 = 0 ;
44829 PyObject * obj1 = 0 ;
44830 char * kwnames[] = {
44831 (char *) "self",(char *) "s", NULL
44832 };
44833
44834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44836 if (!SWIG_IsOK(res1)) {
44837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44838 }
44839 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44840 {
44841 arg2 = wxString_in_helper(obj1);
44842 if (arg2 == NULL) SWIG_fail;
44843 temp2 = true;
44844 }
44845 {
44846 PyThreadState* __tstate = wxPyBeginAllowThreads();
44847 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44848 wxPyEndAllowThreads(__tstate);
44849 if (PyErr_Occurred()) SWIG_fail;
44850 }
44851 {
44852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44853 }
44854 {
44855 if (temp2)
44856 delete arg2;
44857 }
44858 return resultobj;
44859 fail:
44860 {
44861 if (temp2)
44862 delete arg2;
44863 }
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44869 PyObject *resultobj = 0;
44870 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44871 wxString result;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 PyObject *swig_obj[1] ;
44875
44876 if (!args) SWIG_fail;
44877 swig_obj[0] = args;
44878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44881 }
44882 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44883 {
44884 PyThreadState* __tstate = wxPyBeginAllowThreads();
44885 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44886 wxPyEndAllowThreads(__tstate);
44887 if (PyErr_Occurred()) SWIG_fail;
44888 }
44889 {
44890 #if wxUSE_UNICODE
44891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44892 #else
44893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44894 #endif
44895 }
44896 return resultobj;
44897 fail:
44898 return NULL;
44899 }
44900
44901
44902 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44903 PyObject *resultobj = 0;
44904 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44905 int arg2 ;
44906 void *argp1 = 0 ;
44907 int res1 = 0 ;
44908 int val2 ;
44909 int ecode2 = 0 ;
44910 PyObject * obj0 = 0 ;
44911 PyObject * obj1 = 0 ;
44912 char * kwnames[] = {
44913 (char *) "self",(char *) "n", NULL
44914 };
44915
44916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44918 if (!SWIG_IsOK(res1)) {
44919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44920 }
44921 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44922 ecode2 = SWIG_AsVal_int(obj1, &val2);
44923 if (!SWIG_IsOK(ecode2)) {
44924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44925 }
44926 arg2 = static_cast< int >(val2);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 (arg1)->Select(arg2);
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 resultobj = SWIG_Py_Void();
44934 return resultobj;
44935 fail:
44936 return NULL;
44937 }
44938
44939
44940 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44941 PyObject *obj;
44942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44943 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44944 return SWIG_Py_Void();
44945 }
44946
44947 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44948 PyObject *obj;
44949 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44950 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44951 return SWIG_Py_Void();
44952 }
44953
44954 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44955 PyObject *resultobj = 0;
44956 wxSizerItem *result = 0 ;
44957
44958 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44959 {
44960 PyThreadState* __tstate = wxPyBeginAllowThreads();
44961 result = (wxSizerItem *)new wxSizerItem();
44962 wxPyEndAllowThreads(__tstate);
44963 if (PyErr_Occurred()) SWIG_fail;
44964 }
44965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44966 return resultobj;
44967 fail:
44968 return NULL;
44969 }
44970
44971
44972 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44973 PyObject *resultobj = 0;
44974 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44975 void *argp1 = 0 ;
44976 int res1 = 0 ;
44977 PyObject *swig_obj[1] ;
44978
44979 if (!args) SWIG_fail;
44980 swig_obj[0] = args;
44981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44982 if (!SWIG_IsOK(res1)) {
44983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44984 }
44985 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44986 {
44987 PyThreadState* __tstate = wxPyBeginAllowThreads();
44988 delete arg1;
44989
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_Py_Void();
44994 return resultobj;
44995 fail:
44996 return NULL;
44997 }
44998
44999
45000 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45001 PyObject *resultobj = 0;
45002 wxWindow *arg1 = (wxWindow *) 0 ;
45003 int arg2 ;
45004 int arg3 ;
45005 int arg4 ;
45006 PyObject *arg5 = (PyObject *) NULL ;
45007 wxSizerItem *result = 0 ;
45008 void *argp1 = 0 ;
45009 int res1 = 0 ;
45010 int val2 ;
45011 int ecode2 = 0 ;
45012 int val3 ;
45013 int ecode3 = 0 ;
45014 int val4 ;
45015 int ecode4 = 0 ;
45016 PyObject * obj0 = 0 ;
45017 PyObject * obj1 = 0 ;
45018 PyObject * obj2 = 0 ;
45019 PyObject * obj3 = 0 ;
45020 PyObject * obj4 = 0 ;
45021 char * kwnames[] = {
45022 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45023 };
45024
45025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45027 if (!SWIG_IsOK(res1)) {
45028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45029 }
45030 arg1 = reinterpret_cast< wxWindow * >(argp1);
45031 ecode2 = SWIG_AsVal_int(obj1, &val2);
45032 if (!SWIG_IsOK(ecode2)) {
45033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45034 }
45035 arg2 = static_cast< int >(val2);
45036 ecode3 = SWIG_AsVal_int(obj2, &val3);
45037 if (!SWIG_IsOK(ecode3)) {
45038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45039 }
45040 arg3 = static_cast< int >(val3);
45041 ecode4 = SWIG_AsVal_int(obj3, &val4);
45042 if (!SWIG_IsOK(ecode4)) {
45043 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45044 }
45045 arg4 = static_cast< int >(val4);
45046 if (obj4) {
45047 arg5 = obj4;
45048 }
45049 {
45050 PyThreadState* __tstate = wxPyBeginAllowThreads();
45051 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45052 wxPyEndAllowThreads(__tstate);
45053 if (PyErr_Occurred()) SWIG_fail;
45054 }
45055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45056 return resultobj;
45057 fail:
45058 return NULL;
45059 }
45060
45061
45062 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45063 PyObject *resultobj = 0;
45064 int arg1 ;
45065 int arg2 ;
45066 int arg3 ;
45067 int arg4 ;
45068 int arg5 ;
45069 PyObject *arg6 = (PyObject *) NULL ;
45070 wxSizerItem *result = 0 ;
45071 int val1 ;
45072 int ecode1 = 0 ;
45073 int val2 ;
45074 int ecode2 = 0 ;
45075 int val3 ;
45076 int ecode3 = 0 ;
45077 int val4 ;
45078 int ecode4 = 0 ;
45079 int val5 ;
45080 int ecode5 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 PyObject * obj2 = 0 ;
45084 PyObject * obj3 = 0 ;
45085 PyObject * obj4 = 0 ;
45086 PyObject * obj5 = 0 ;
45087 char * kwnames[] = {
45088 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45089 };
45090
45091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45092 ecode1 = SWIG_AsVal_int(obj0, &val1);
45093 if (!SWIG_IsOK(ecode1)) {
45094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45095 }
45096 arg1 = static_cast< int >(val1);
45097 ecode2 = SWIG_AsVal_int(obj1, &val2);
45098 if (!SWIG_IsOK(ecode2)) {
45099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45100 }
45101 arg2 = static_cast< int >(val2);
45102 ecode3 = SWIG_AsVal_int(obj2, &val3);
45103 if (!SWIG_IsOK(ecode3)) {
45104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45105 }
45106 arg3 = static_cast< int >(val3);
45107 ecode4 = SWIG_AsVal_int(obj3, &val4);
45108 if (!SWIG_IsOK(ecode4)) {
45109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45110 }
45111 arg4 = static_cast< int >(val4);
45112 ecode5 = SWIG_AsVal_int(obj4, &val5);
45113 if (!SWIG_IsOK(ecode5)) {
45114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45115 }
45116 arg5 = static_cast< int >(val5);
45117 if (obj5) {
45118 arg6 = obj5;
45119 }
45120 {
45121 PyThreadState* __tstate = wxPyBeginAllowThreads();
45122 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45123 wxPyEndAllowThreads(__tstate);
45124 if (PyErr_Occurred()) SWIG_fail;
45125 }
45126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45127 return resultobj;
45128 fail:
45129 return NULL;
45130 }
45131
45132
45133 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45134 PyObject *resultobj = 0;
45135 wxSizer *arg1 = (wxSizer *) 0 ;
45136 int arg2 ;
45137 int arg3 ;
45138 int arg4 ;
45139 PyObject *arg5 = (PyObject *) NULL ;
45140 wxSizerItem *result = 0 ;
45141 int res1 = 0 ;
45142 int val2 ;
45143 int ecode2 = 0 ;
45144 int val3 ;
45145 int ecode3 = 0 ;
45146 int val4 ;
45147 int ecode4 = 0 ;
45148 PyObject * obj0 = 0 ;
45149 PyObject * obj1 = 0 ;
45150 PyObject * obj2 = 0 ;
45151 PyObject * obj3 = 0 ;
45152 PyObject * obj4 = 0 ;
45153 char * kwnames[] = {
45154 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45155 };
45156
45157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45158 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45159 if (!SWIG_IsOK(res1)) {
45160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45161 }
45162 ecode2 = SWIG_AsVal_int(obj1, &val2);
45163 if (!SWIG_IsOK(ecode2)) {
45164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45165 }
45166 arg2 = static_cast< int >(val2);
45167 ecode3 = SWIG_AsVal_int(obj2, &val3);
45168 if (!SWIG_IsOK(ecode3)) {
45169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45170 }
45171 arg3 = static_cast< int >(val3);
45172 ecode4 = SWIG_AsVal_int(obj3, &val4);
45173 if (!SWIG_IsOK(ecode4)) {
45174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45175 }
45176 arg4 = static_cast< int >(val4);
45177 if (obj4) {
45178 arg5 = obj4;
45179 }
45180 {
45181 PyThreadState* __tstate = wxPyBeginAllowThreads();
45182 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45183 wxPyEndAllowThreads(__tstate);
45184 if (PyErr_Occurred()) SWIG_fail;
45185 }
45186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45187 return resultobj;
45188 fail:
45189 return NULL;
45190 }
45191
45192
45193 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45194 PyObject *resultobj = 0;
45195 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45196 void *argp1 = 0 ;
45197 int res1 = 0 ;
45198 PyObject *swig_obj[1] ;
45199
45200 if (!args) SWIG_fail;
45201 swig_obj[0] = args;
45202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45203 if (!SWIG_IsOK(res1)) {
45204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45205 }
45206 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45207 {
45208 PyThreadState* __tstate = wxPyBeginAllowThreads();
45209 (arg1)->DeleteWindows();
45210 wxPyEndAllowThreads(__tstate);
45211 if (PyErr_Occurred()) SWIG_fail;
45212 }
45213 resultobj = SWIG_Py_Void();
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45221 PyObject *resultobj = 0;
45222 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45223 void *argp1 = 0 ;
45224 int res1 = 0 ;
45225 PyObject *swig_obj[1] ;
45226
45227 if (!args) SWIG_fail;
45228 swig_obj[0] = args;
45229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45230 if (!SWIG_IsOK(res1)) {
45231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45232 }
45233 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45234 {
45235 PyThreadState* __tstate = wxPyBeginAllowThreads();
45236 (arg1)->DetachSizer();
45237 wxPyEndAllowThreads(__tstate);
45238 if (PyErr_Occurred()) SWIG_fail;
45239 }
45240 resultobj = SWIG_Py_Void();
45241 return resultobj;
45242 fail:
45243 return NULL;
45244 }
45245
45246
45247 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45248 PyObject *resultobj = 0;
45249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45250 wxSize result;
45251 void *argp1 = 0 ;
45252 int res1 = 0 ;
45253 PyObject *swig_obj[1] ;
45254
45255 if (!args) SWIG_fail;
45256 swig_obj[0] = args;
45257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45258 if (!SWIG_IsOK(res1)) {
45259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45260 }
45261 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45262 {
45263 PyThreadState* __tstate = wxPyBeginAllowThreads();
45264 result = (arg1)->GetSize();
45265 wxPyEndAllowThreads(__tstate);
45266 if (PyErr_Occurred()) SWIG_fail;
45267 }
45268 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45269 return resultobj;
45270 fail:
45271 return NULL;
45272 }
45273
45274
45275 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45276 PyObject *resultobj = 0;
45277 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45278 wxSize result;
45279 void *argp1 = 0 ;
45280 int res1 = 0 ;
45281 PyObject *swig_obj[1] ;
45282
45283 if (!args) SWIG_fail;
45284 swig_obj[0] = args;
45285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45286 if (!SWIG_IsOK(res1)) {
45287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45288 }
45289 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45290 {
45291 PyThreadState* __tstate = wxPyBeginAllowThreads();
45292 result = (arg1)->CalcMin();
45293 wxPyEndAllowThreads(__tstate);
45294 if (PyErr_Occurred()) SWIG_fail;
45295 }
45296 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45297 return resultobj;
45298 fail:
45299 return NULL;
45300 }
45301
45302
45303 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45304 PyObject *resultobj = 0;
45305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45306 wxPoint *arg2 = 0 ;
45307 wxSize *arg3 = 0 ;
45308 void *argp1 = 0 ;
45309 int res1 = 0 ;
45310 wxPoint temp2 ;
45311 wxSize temp3 ;
45312 PyObject * obj0 = 0 ;
45313 PyObject * obj1 = 0 ;
45314 PyObject * obj2 = 0 ;
45315 char * kwnames[] = {
45316 (char *) "self",(char *) "pos",(char *) "size", NULL
45317 };
45318
45319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45321 if (!SWIG_IsOK(res1)) {
45322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45323 }
45324 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45325 {
45326 arg2 = &temp2;
45327 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45328 }
45329 {
45330 arg3 = &temp3;
45331 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45332 }
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 resultobj = SWIG_Py_Void();
45340 return resultobj;
45341 fail:
45342 return NULL;
45343 }
45344
45345
45346 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45347 PyObject *resultobj = 0;
45348 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45349 wxSize result;
45350 void *argp1 = 0 ;
45351 int res1 = 0 ;
45352 PyObject *swig_obj[1] ;
45353
45354 if (!args) SWIG_fail;
45355 swig_obj[0] = args;
45356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45357 if (!SWIG_IsOK(res1)) {
45358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45359 }
45360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45361 {
45362 PyThreadState* __tstate = wxPyBeginAllowThreads();
45363 result = (arg1)->GetMinSize();
45364 wxPyEndAllowThreads(__tstate);
45365 if (PyErr_Occurred()) SWIG_fail;
45366 }
45367 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45368 return resultobj;
45369 fail:
45370 return NULL;
45371 }
45372
45373
45374 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45375 PyObject *resultobj = 0;
45376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45377 wxSize result;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 PyObject *swig_obj[1] ;
45381
45382 if (!args) SWIG_fail;
45383 swig_obj[0] = args;
45384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45385 if (!SWIG_IsOK(res1)) {
45386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45387 }
45388 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45389 {
45390 PyThreadState* __tstate = wxPyBeginAllowThreads();
45391 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45396 return resultobj;
45397 fail:
45398 return NULL;
45399 }
45400
45401
45402 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45403 PyObject *resultobj = 0;
45404 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45405 int arg2 ;
45406 int arg3 ;
45407 void *argp1 = 0 ;
45408 int res1 = 0 ;
45409 int val2 ;
45410 int ecode2 = 0 ;
45411 int val3 ;
45412 int ecode3 = 0 ;
45413 PyObject * obj0 = 0 ;
45414 PyObject * obj1 = 0 ;
45415 PyObject * obj2 = 0 ;
45416 char * kwnames[] = {
45417 (char *) "self",(char *) "x",(char *) "y", NULL
45418 };
45419
45420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45422 if (!SWIG_IsOK(res1)) {
45423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45424 }
45425 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45426 ecode2 = SWIG_AsVal_int(obj1, &val2);
45427 if (!SWIG_IsOK(ecode2)) {
45428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45429 }
45430 arg2 = static_cast< int >(val2);
45431 ecode3 = SWIG_AsVal_int(obj2, &val3);
45432 if (!SWIG_IsOK(ecode3)) {
45433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45434 }
45435 arg3 = static_cast< int >(val3);
45436 {
45437 PyThreadState* __tstate = wxPyBeginAllowThreads();
45438 (arg1)->SetInitSize(arg2,arg3);
45439 wxPyEndAllowThreads(__tstate);
45440 if (PyErr_Occurred()) SWIG_fail;
45441 }
45442 resultobj = SWIG_Py_Void();
45443 return resultobj;
45444 fail:
45445 return NULL;
45446 }
45447
45448
45449 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45450 PyObject *resultobj = 0;
45451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45452 int arg2 ;
45453 int arg3 ;
45454 void *argp1 = 0 ;
45455 int res1 = 0 ;
45456 int val2 ;
45457 int ecode2 = 0 ;
45458 int val3 ;
45459 int ecode3 = 0 ;
45460 PyObject * obj0 = 0 ;
45461 PyObject * obj1 = 0 ;
45462 PyObject * obj2 = 0 ;
45463 char * kwnames[] = {
45464 (char *) "self",(char *) "width",(char *) "height", NULL
45465 };
45466
45467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45469 if (!SWIG_IsOK(res1)) {
45470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45471 }
45472 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45473 ecode2 = SWIG_AsVal_int(obj1, &val2);
45474 if (!SWIG_IsOK(ecode2)) {
45475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45476 }
45477 arg2 = static_cast< int >(val2);
45478 ecode3 = SWIG_AsVal_int(obj2, &val3);
45479 if (!SWIG_IsOK(ecode3)) {
45480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45481 }
45482 arg3 = static_cast< int >(val3);
45483 {
45484 PyThreadState* __tstate = wxPyBeginAllowThreads();
45485 (arg1)->SetRatio(arg2,arg3);
45486 wxPyEndAllowThreads(__tstate);
45487 if (PyErr_Occurred()) SWIG_fail;
45488 }
45489 resultobj = SWIG_Py_Void();
45490 return resultobj;
45491 fail:
45492 return NULL;
45493 }
45494
45495
45496 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45497 PyObject *resultobj = 0;
45498 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45499 wxSize *arg2 = 0 ;
45500 void *argp1 = 0 ;
45501 int res1 = 0 ;
45502 wxSize temp2 ;
45503 PyObject * obj0 = 0 ;
45504 PyObject * obj1 = 0 ;
45505 char * kwnames[] = {
45506 (char *) "self",(char *) "size", NULL
45507 };
45508
45509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45511 if (!SWIG_IsOK(res1)) {
45512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45513 }
45514 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45515 {
45516 arg2 = &temp2;
45517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45518 }
45519 {
45520 PyThreadState* __tstate = wxPyBeginAllowThreads();
45521 (arg1)->SetRatio((wxSize const &)*arg2);
45522 wxPyEndAllowThreads(__tstate);
45523 if (PyErr_Occurred()) SWIG_fail;
45524 }
45525 resultobj = SWIG_Py_Void();
45526 return resultobj;
45527 fail:
45528 return NULL;
45529 }
45530
45531
45532 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45533 PyObject *resultobj = 0;
45534 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45535 float arg2 ;
45536 void *argp1 = 0 ;
45537 int res1 = 0 ;
45538 float val2 ;
45539 int ecode2 = 0 ;
45540 PyObject * obj0 = 0 ;
45541 PyObject * obj1 = 0 ;
45542 char * kwnames[] = {
45543 (char *) "self",(char *) "ratio", NULL
45544 };
45545
45546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45548 if (!SWIG_IsOK(res1)) {
45549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45550 }
45551 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45552 ecode2 = SWIG_AsVal_float(obj1, &val2);
45553 if (!SWIG_IsOK(ecode2)) {
45554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45555 }
45556 arg2 = static_cast< float >(val2);
45557 {
45558 PyThreadState* __tstate = wxPyBeginAllowThreads();
45559 (arg1)->SetRatio(arg2);
45560 wxPyEndAllowThreads(__tstate);
45561 if (PyErr_Occurred()) SWIG_fail;
45562 }
45563 resultobj = SWIG_Py_Void();
45564 return resultobj;
45565 fail:
45566 return NULL;
45567 }
45568
45569
45570 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45571 PyObject *resultobj = 0;
45572 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45573 float result;
45574 void *argp1 = 0 ;
45575 int res1 = 0 ;
45576 PyObject *swig_obj[1] ;
45577
45578 if (!args) SWIG_fail;
45579 swig_obj[0] = args;
45580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45583 }
45584 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45585 {
45586 PyThreadState* __tstate = wxPyBeginAllowThreads();
45587 result = (float)(arg1)->GetRatio();
45588 wxPyEndAllowThreads(__tstate);
45589 if (PyErr_Occurred()) SWIG_fail;
45590 }
45591 resultobj = SWIG_From_float(static_cast< float >(result));
45592 return resultobj;
45593 fail:
45594 return NULL;
45595 }
45596
45597
45598 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45599 PyObject *resultobj = 0;
45600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45601 wxRect result;
45602 void *argp1 = 0 ;
45603 int res1 = 0 ;
45604 PyObject *swig_obj[1] ;
45605
45606 if (!args) SWIG_fail;
45607 swig_obj[0] = args;
45608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45609 if (!SWIG_IsOK(res1)) {
45610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45611 }
45612 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45613 {
45614 PyThreadState* __tstate = wxPyBeginAllowThreads();
45615 result = (arg1)->GetRect();
45616 wxPyEndAllowThreads(__tstate);
45617 if (PyErr_Occurred()) SWIG_fail;
45618 }
45619 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45620 return resultobj;
45621 fail:
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45627 PyObject *resultobj = 0;
45628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45629 bool result;
45630 void *argp1 = 0 ;
45631 int res1 = 0 ;
45632 PyObject *swig_obj[1] ;
45633
45634 if (!args) SWIG_fail;
45635 swig_obj[0] = args;
45636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45637 if (!SWIG_IsOK(res1)) {
45638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45639 }
45640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45641 {
45642 PyThreadState* __tstate = wxPyBeginAllowThreads();
45643 result = (bool)(arg1)->IsWindow();
45644 wxPyEndAllowThreads(__tstate);
45645 if (PyErr_Occurred()) SWIG_fail;
45646 }
45647 {
45648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45649 }
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45657 PyObject *resultobj = 0;
45658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45659 bool result;
45660 void *argp1 = 0 ;
45661 int res1 = 0 ;
45662 PyObject *swig_obj[1] ;
45663
45664 if (!args) SWIG_fail;
45665 swig_obj[0] = args;
45666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45667 if (!SWIG_IsOK(res1)) {
45668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45669 }
45670 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45671 {
45672 PyThreadState* __tstate = wxPyBeginAllowThreads();
45673 result = (bool)(arg1)->IsSizer();
45674 wxPyEndAllowThreads(__tstate);
45675 if (PyErr_Occurred()) SWIG_fail;
45676 }
45677 {
45678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45679 }
45680 return resultobj;
45681 fail:
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45687 PyObject *resultobj = 0;
45688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45689 bool result;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 PyObject *swig_obj[1] ;
45693
45694 if (!args) SWIG_fail;
45695 swig_obj[0] = args;
45696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45699 }
45700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45701 {
45702 PyThreadState* __tstate = wxPyBeginAllowThreads();
45703 result = (bool)(arg1)->IsSpacer();
45704 wxPyEndAllowThreads(__tstate);
45705 if (PyErr_Occurred()) SWIG_fail;
45706 }
45707 {
45708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45709 }
45710 return resultobj;
45711 fail:
45712 return NULL;
45713 }
45714
45715
45716 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45717 PyObject *resultobj = 0;
45718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45719 int arg2 ;
45720 void *argp1 = 0 ;
45721 int res1 = 0 ;
45722 int val2 ;
45723 int ecode2 = 0 ;
45724 PyObject * obj0 = 0 ;
45725 PyObject * obj1 = 0 ;
45726 char * kwnames[] = {
45727 (char *) "self",(char *) "proportion", NULL
45728 };
45729
45730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45732 if (!SWIG_IsOK(res1)) {
45733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45734 }
45735 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45736 ecode2 = SWIG_AsVal_int(obj1, &val2);
45737 if (!SWIG_IsOK(ecode2)) {
45738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45739 }
45740 arg2 = static_cast< int >(val2);
45741 {
45742 PyThreadState* __tstate = wxPyBeginAllowThreads();
45743 (arg1)->SetProportion(arg2);
45744 wxPyEndAllowThreads(__tstate);
45745 if (PyErr_Occurred()) SWIG_fail;
45746 }
45747 resultobj = SWIG_Py_Void();
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45755 PyObject *resultobj = 0;
45756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45757 int result;
45758 void *argp1 = 0 ;
45759 int res1 = 0 ;
45760 PyObject *swig_obj[1] ;
45761
45762 if (!args) SWIG_fail;
45763 swig_obj[0] = args;
45764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45765 if (!SWIG_IsOK(res1)) {
45766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45767 }
45768 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45769 {
45770 PyThreadState* __tstate = wxPyBeginAllowThreads();
45771 result = (int)(arg1)->GetProportion();
45772 wxPyEndAllowThreads(__tstate);
45773 if (PyErr_Occurred()) SWIG_fail;
45774 }
45775 resultobj = SWIG_From_int(static_cast< int >(result));
45776 return resultobj;
45777 fail:
45778 return NULL;
45779 }
45780
45781
45782 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45783 PyObject *resultobj = 0;
45784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45785 int arg2 ;
45786 void *argp1 = 0 ;
45787 int res1 = 0 ;
45788 int val2 ;
45789 int ecode2 = 0 ;
45790 PyObject * obj0 = 0 ;
45791 PyObject * obj1 = 0 ;
45792 char * kwnames[] = {
45793 (char *) "self",(char *) "flag", NULL
45794 };
45795
45796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45798 if (!SWIG_IsOK(res1)) {
45799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45800 }
45801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45802 ecode2 = SWIG_AsVal_int(obj1, &val2);
45803 if (!SWIG_IsOK(ecode2)) {
45804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45805 }
45806 arg2 = static_cast< int >(val2);
45807 {
45808 PyThreadState* __tstate = wxPyBeginAllowThreads();
45809 (arg1)->SetFlag(arg2);
45810 wxPyEndAllowThreads(__tstate);
45811 if (PyErr_Occurred()) SWIG_fail;
45812 }
45813 resultobj = SWIG_Py_Void();
45814 return resultobj;
45815 fail:
45816 return NULL;
45817 }
45818
45819
45820 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45821 PyObject *resultobj = 0;
45822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45823 int result;
45824 void *argp1 = 0 ;
45825 int res1 = 0 ;
45826 PyObject *swig_obj[1] ;
45827
45828 if (!args) SWIG_fail;
45829 swig_obj[0] = args;
45830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45833 }
45834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45835 {
45836 PyThreadState* __tstate = wxPyBeginAllowThreads();
45837 result = (int)(arg1)->GetFlag();
45838 wxPyEndAllowThreads(__tstate);
45839 if (PyErr_Occurred()) SWIG_fail;
45840 }
45841 resultobj = SWIG_From_int(static_cast< int >(result));
45842 return resultobj;
45843 fail:
45844 return NULL;
45845 }
45846
45847
45848 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45849 PyObject *resultobj = 0;
45850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45851 int arg2 ;
45852 void *argp1 = 0 ;
45853 int res1 = 0 ;
45854 int val2 ;
45855 int ecode2 = 0 ;
45856 PyObject * obj0 = 0 ;
45857 PyObject * obj1 = 0 ;
45858 char * kwnames[] = {
45859 (char *) "self",(char *) "border", NULL
45860 };
45861
45862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45864 if (!SWIG_IsOK(res1)) {
45865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45866 }
45867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45868 ecode2 = SWIG_AsVal_int(obj1, &val2);
45869 if (!SWIG_IsOK(ecode2)) {
45870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45871 }
45872 arg2 = static_cast< int >(val2);
45873 {
45874 PyThreadState* __tstate = wxPyBeginAllowThreads();
45875 (arg1)->SetBorder(arg2);
45876 wxPyEndAllowThreads(__tstate);
45877 if (PyErr_Occurred()) SWIG_fail;
45878 }
45879 resultobj = SWIG_Py_Void();
45880 return resultobj;
45881 fail:
45882 return NULL;
45883 }
45884
45885
45886 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45887 PyObject *resultobj = 0;
45888 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45889 int result;
45890 void *argp1 = 0 ;
45891 int res1 = 0 ;
45892 PyObject *swig_obj[1] ;
45893
45894 if (!args) SWIG_fail;
45895 swig_obj[0] = args;
45896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45897 if (!SWIG_IsOK(res1)) {
45898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45899 }
45900 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45901 {
45902 PyThreadState* __tstate = wxPyBeginAllowThreads();
45903 result = (int)(arg1)->GetBorder();
45904 wxPyEndAllowThreads(__tstate);
45905 if (PyErr_Occurred()) SWIG_fail;
45906 }
45907 resultobj = SWIG_From_int(static_cast< int >(result));
45908 return resultobj;
45909 fail:
45910 return NULL;
45911 }
45912
45913
45914 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45915 PyObject *resultobj = 0;
45916 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45917 wxWindow *result = 0 ;
45918 void *argp1 = 0 ;
45919 int res1 = 0 ;
45920 PyObject *swig_obj[1] ;
45921
45922 if (!args) SWIG_fail;
45923 swig_obj[0] = args;
45924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45925 if (!SWIG_IsOK(res1)) {
45926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45927 }
45928 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45929 {
45930 PyThreadState* __tstate = wxPyBeginAllowThreads();
45931 result = (wxWindow *)(arg1)->GetWindow();
45932 wxPyEndAllowThreads(__tstate);
45933 if (PyErr_Occurred()) SWIG_fail;
45934 }
45935 {
45936 resultobj = wxPyMake_wxObject(result, 0);
45937 }
45938 return resultobj;
45939 fail:
45940 return NULL;
45941 }
45942
45943
45944 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45945 PyObject *resultobj = 0;
45946 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45947 wxWindow *arg2 = (wxWindow *) 0 ;
45948 void *argp1 = 0 ;
45949 int res1 = 0 ;
45950 void *argp2 = 0 ;
45951 int res2 = 0 ;
45952 PyObject * obj0 = 0 ;
45953 PyObject * obj1 = 0 ;
45954 char * kwnames[] = {
45955 (char *) "self",(char *) "window", NULL
45956 };
45957
45958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45960 if (!SWIG_IsOK(res1)) {
45961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45962 }
45963 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45965 if (!SWIG_IsOK(res2)) {
45966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45967 }
45968 arg2 = reinterpret_cast< wxWindow * >(argp2);
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 (arg1)->SetWindow(arg2);
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 resultobj = SWIG_Py_Void();
45976 return resultobj;
45977 fail:
45978 return NULL;
45979 }
45980
45981
45982 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45983 PyObject *resultobj = 0;
45984 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45985 wxSizer *result = 0 ;
45986 void *argp1 = 0 ;
45987 int res1 = 0 ;
45988 PyObject *swig_obj[1] ;
45989
45990 if (!args) SWIG_fail;
45991 swig_obj[0] = args;
45992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45995 }
45996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 result = (wxSizer *)(arg1)->GetSizer();
46000 wxPyEndAllowThreads(__tstate);
46001 if (PyErr_Occurred()) SWIG_fail;
46002 }
46003 {
46004 resultobj = wxPyMake_wxObject(result, (bool)0);
46005 }
46006 return resultobj;
46007 fail:
46008 return NULL;
46009 }
46010
46011
46012 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46013 PyObject *resultobj = 0;
46014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46015 wxSizer *arg2 = (wxSizer *) 0 ;
46016 void *argp1 = 0 ;
46017 int res1 = 0 ;
46018 int res2 = 0 ;
46019 PyObject * obj0 = 0 ;
46020 PyObject * obj1 = 0 ;
46021 char * kwnames[] = {
46022 (char *) "self",(char *) "sizer", NULL
46023 };
46024
46025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46027 if (!SWIG_IsOK(res1)) {
46028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46029 }
46030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46031 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46032 if (!SWIG_IsOK(res2)) {
46033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46034 }
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 (arg1)->SetSizer(arg2);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_Py_Void();
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 wxSize *result = 0 ;
46052 void *argp1 = 0 ;
46053 int res1 = 0 ;
46054 PyObject *swig_obj[1] ;
46055
46056 if (!args) SWIG_fail;
46057 swig_obj[0] = args;
46058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46059 if (!SWIG_IsOK(res1)) {
46060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46061 }
46062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 {
46066 wxSize const &_result_ref = (arg1)->GetSpacer();
46067 result = (wxSize *) &_result_ref;
46068 }
46069 wxPyEndAllowThreads(__tstate);
46070 if (PyErr_Occurred()) SWIG_fail;
46071 }
46072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = 0;
46081 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46082 wxSize *arg2 = 0 ;
46083 void *argp1 = 0 ;
46084 int res1 = 0 ;
46085 wxSize temp2 ;
46086 PyObject * obj0 = 0 ;
46087 PyObject * obj1 = 0 ;
46088 char * kwnames[] = {
46089 (char *) "self",(char *) "size", NULL
46090 };
46091
46092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46094 if (!SWIG_IsOK(res1)) {
46095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46096 }
46097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46098 {
46099 arg2 = &temp2;
46100 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46101 }
46102 {
46103 PyThreadState* __tstate = wxPyBeginAllowThreads();
46104 (arg1)->SetSpacer((wxSize const &)*arg2);
46105 wxPyEndAllowThreads(__tstate);
46106 if (PyErr_Occurred()) SWIG_fail;
46107 }
46108 resultobj = SWIG_Py_Void();
46109 return resultobj;
46110 fail:
46111 return NULL;
46112 }
46113
46114
46115 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46116 PyObject *resultobj = 0;
46117 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46118 bool arg2 ;
46119 void *argp1 = 0 ;
46120 int res1 = 0 ;
46121 bool val2 ;
46122 int ecode2 = 0 ;
46123 PyObject * obj0 = 0 ;
46124 PyObject * obj1 = 0 ;
46125 char * kwnames[] = {
46126 (char *) "self",(char *) "show", NULL
46127 };
46128
46129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46131 if (!SWIG_IsOK(res1)) {
46132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46133 }
46134 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46135 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46136 if (!SWIG_IsOK(ecode2)) {
46137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46138 }
46139 arg2 = static_cast< bool >(val2);
46140 {
46141 PyThreadState* __tstate = wxPyBeginAllowThreads();
46142 (arg1)->Show(arg2);
46143 wxPyEndAllowThreads(__tstate);
46144 if (PyErr_Occurred()) SWIG_fail;
46145 }
46146 resultobj = SWIG_Py_Void();
46147 return resultobj;
46148 fail:
46149 return NULL;
46150 }
46151
46152
46153 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46154 PyObject *resultobj = 0;
46155 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46156 bool result;
46157 void *argp1 = 0 ;
46158 int res1 = 0 ;
46159 PyObject *swig_obj[1] ;
46160
46161 if (!args) SWIG_fail;
46162 swig_obj[0] = args;
46163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46164 if (!SWIG_IsOK(res1)) {
46165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46166 }
46167 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46168 {
46169 PyThreadState* __tstate = wxPyBeginAllowThreads();
46170 result = (bool)(arg1)->IsShown();
46171 wxPyEndAllowThreads(__tstate);
46172 if (PyErr_Occurred()) SWIG_fail;
46173 }
46174 {
46175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46176 }
46177 return resultobj;
46178 fail:
46179 return NULL;
46180 }
46181
46182
46183 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46184 PyObject *resultobj = 0;
46185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46186 wxPoint result;
46187 void *argp1 = 0 ;
46188 int res1 = 0 ;
46189 PyObject *swig_obj[1] ;
46190
46191 if (!args) SWIG_fail;
46192 swig_obj[0] = args;
46193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46194 if (!SWIG_IsOK(res1)) {
46195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46196 }
46197 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46198 {
46199 PyThreadState* __tstate = wxPyBeginAllowThreads();
46200 result = (arg1)->GetPosition();
46201 wxPyEndAllowThreads(__tstate);
46202 if (PyErr_Occurred()) SWIG_fail;
46203 }
46204 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46205 return resultobj;
46206 fail:
46207 return NULL;
46208 }
46209
46210
46211 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46212 PyObject *resultobj = 0;
46213 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46214 PyObject *result = 0 ;
46215 void *argp1 = 0 ;
46216 int res1 = 0 ;
46217 PyObject *swig_obj[1] ;
46218
46219 if (!args) SWIG_fail;
46220 swig_obj[0] = args;
46221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46222 if (!SWIG_IsOK(res1)) {
46223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46224 }
46225 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46226 {
46227 PyThreadState* __tstate = wxPyBeginAllowThreads();
46228 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46229 wxPyEndAllowThreads(__tstate);
46230 if (PyErr_Occurred()) SWIG_fail;
46231 }
46232 resultobj = result;
46233 return resultobj;
46234 fail:
46235 return NULL;
46236 }
46237
46238
46239 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46240 PyObject *resultobj = 0;
46241 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46242 PyObject *arg2 = (PyObject *) 0 ;
46243 void *argp1 = 0 ;
46244 int res1 = 0 ;
46245 PyObject * obj0 = 0 ;
46246 PyObject * obj1 = 0 ;
46247 char * kwnames[] = {
46248 (char *) "self",(char *) "userData", NULL
46249 };
46250
46251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",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_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46255 }
46256 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46257 arg2 = obj1;
46258 {
46259 PyThreadState* __tstate = wxPyBeginAllowThreads();
46260 wxSizerItem_SetUserData(arg1,arg2);
46261 wxPyEndAllowThreads(__tstate);
46262 if (PyErr_Occurred()) SWIG_fail;
46263 }
46264 resultobj = SWIG_Py_Void();
46265 return resultobj;
46266 fail:
46267 return NULL;
46268 }
46269
46270
46271 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46272 PyObject *obj;
46273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46274 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46275 return SWIG_Py_Void();
46276 }
46277
46278 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46279 return SWIG_Python_InitShadowInstance(args);
46280 }
46281
46282 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46283 PyObject *resultobj = 0;
46284 wxSizer *arg1 = (wxSizer *) 0 ;
46285 void *argp1 = 0 ;
46286 int res1 = 0 ;
46287 PyObject *swig_obj[1] ;
46288
46289 if (!args) SWIG_fail;
46290 swig_obj[0] = args;
46291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46292 if (!SWIG_IsOK(res1)) {
46293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46294 }
46295 arg1 = reinterpret_cast< wxSizer * >(argp1);
46296 {
46297 PyThreadState* __tstate = wxPyBeginAllowThreads();
46298 delete arg1;
46299
46300 wxPyEndAllowThreads(__tstate);
46301 if (PyErr_Occurred()) SWIG_fail;
46302 }
46303 resultobj = SWIG_Py_Void();
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxSizer *arg1 = (wxSizer *) 0 ;
46313 PyObject *arg2 = (PyObject *) 0 ;
46314 void *argp1 = 0 ;
46315 int res1 = 0 ;
46316 PyObject * obj0 = 0 ;
46317 PyObject * obj1 = 0 ;
46318 char * kwnames[] = {
46319 (char *) "self",(char *) "_self", NULL
46320 };
46321
46322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46324 if (!SWIG_IsOK(res1)) {
46325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46326 }
46327 arg1 = reinterpret_cast< wxSizer * >(argp1);
46328 arg2 = obj1;
46329 {
46330 PyThreadState* __tstate = wxPyBeginAllowThreads();
46331 wxSizer__setOORInfo(arg1,arg2);
46332 wxPyEndAllowThreads(__tstate);
46333 if (PyErr_Occurred()) SWIG_fail;
46334 }
46335 resultobj = SWIG_Py_Void();
46336 return resultobj;
46337 fail:
46338 return NULL;
46339 }
46340
46341
46342 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46343 PyObject *resultobj = 0;
46344 wxSizer *arg1 = (wxSizer *) 0 ;
46345 PyObject *arg2 = (PyObject *) 0 ;
46346 int arg3 = (int) 0 ;
46347 int arg4 = (int) 0 ;
46348 int arg5 = (int) 0 ;
46349 PyObject *arg6 = (PyObject *) NULL ;
46350 wxSizerItem *result = 0 ;
46351 void *argp1 = 0 ;
46352 int res1 = 0 ;
46353 int val3 ;
46354 int ecode3 = 0 ;
46355 int val4 ;
46356 int ecode4 = 0 ;
46357 int val5 ;
46358 int ecode5 = 0 ;
46359 PyObject * obj0 = 0 ;
46360 PyObject * obj1 = 0 ;
46361 PyObject * obj2 = 0 ;
46362 PyObject * obj3 = 0 ;
46363 PyObject * obj4 = 0 ;
46364 PyObject * obj5 = 0 ;
46365 char * kwnames[] = {
46366 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46367 };
46368
46369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46371 if (!SWIG_IsOK(res1)) {
46372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46373 }
46374 arg1 = reinterpret_cast< wxSizer * >(argp1);
46375 arg2 = obj1;
46376 if (obj2) {
46377 ecode3 = SWIG_AsVal_int(obj2, &val3);
46378 if (!SWIG_IsOK(ecode3)) {
46379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46380 }
46381 arg3 = static_cast< int >(val3);
46382 }
46383 if (obj3) {
46384 ecode4 = SWIG_AsVal_int(obj3, &val4);
46385 if (!SWIG_IsOK(ecode4)) {
46386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46387 }
46388 arg4 = static_cast< int >(val4);
46389 }
46390 if (obj4) {
46391 ecode5 = SWIG_AsVal_int(obj4, &val5);
46392 if (!SWIG_IsOK(ecode5)) {
46393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46394 }
46395 arg5 = static_cast< int >(val5);
46396 }
46397 if (obj5) {
46398 arg6 = obj5;
46399 }
46400 {
46401 PyThreadState* __tstate = wxPyBeginAllowThreads();
46402 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46403 wxPyEndAllowThreads(__tstate);
46404 if (PyErr_Occurred()) SWIG_fail;
46405 }
46406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46407 return resultobj;
46408 fail:
46409 return NULL;
46410 }
46411
46412
46413 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46414 PyObject *resultobj = 0;
46415 wxSizer *arg1 = (wxSizer *) 0 ;
46416 int arg2 ;
46417 PyObject *arg3 = (PyObject *) 0 ;
46418 int arg4 = (int) 0 ;
46419 int arg5 = (int) 0 ;
46420 int arg6 = (int) 0 ;
46421 PyObject *arg7 = (PyObject *) NULL ;
46422 wxSizerItem *result = 0 ;
46423 void *argp1 = 0 ;
46424 int res1 = 0 ;
46425 int val2 ;
46426 int ecode2 = 0 ;
46427 int val4 ;
46428 int ecode4 = 0 ;
46429 int val5 ;
46430 int ecode5 = 0 ;
46431 int val6 ;
46432 int ecode6 = 0 ;
46433 PyObject * obj0 = 0 ;
46434 PyObject * obj1 = 0 ;
46435 PyObject * obj2 = 0 ;
46436 PyObject * obj3 = 0 ;
46437 PyObject * obj4 = 0 ;
46438 PyObject * obj5 = 0 ;
46439 PyObject * obj6 = 0 ;
46440 char * kwnames[] = {
46441 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46442 };
46443
46444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46446 if (!SWIG_IsOK(res1)) {
46447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46448 }
46449 arg1 = reinterpret_cast< wxSizer * >(argp1);
46450 ecode2 = SWIG_AsVal_int(obj1, &val2);
46451 if (!SWIG_IsOK(ecode2)) {
46452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46453 }
46454 arg2 = static_cast< int >(val2);
46455 arg3 = obj2;
46456 if (obj3) {
46457 ecode4 = SWIG_AsVal_int(obj3, &val4);
46458 if (!SWIG_IsOK(ecode4)) {
46459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46460 }
46461 arg4 = static_cast< int >(val4);
46462 }
46463 if (obj4) {
46464 ecode5 = SWIG_AsVal_int(obj4, &val5);
46465 if (!SWIG_IsOK(ecode5)) {
46466 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46467 }
46468 arg5 = static_cast< int >(val5);
46469 }
46470 if (obj5) {
46471 ecode6 = SWIG_AsVal_int(obj5, &val6);
46472 if (!SWIG_IsOK(ecode6)) {
46473 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46474 }
46475 arg6 = static_cast< int >(val6);
46476 }
46477 if (obj6) {
46478 arg7 = obj6;
46479 }
46480 {
46481 PyThreadState* __tstate = wxPyBeginAllowThreads();
46482 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46483 wxPyEndAllowThreads(__tstate);
46484 if (PyErr_Occurred()) SWIG_fail;
46485 }
46486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46487 return resultobj;
46488 fail:
46489 return NULL;
46490 }
46491
46492
46493 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46494 PyObject *resultobj = 0;
46495 wxSizer *arg1 = (wxSizer *) 0 ;
46496 PyObject *arg2 = (PyObject *) 0 ;
46497 int arg3 = (int) 0 ;
46498 int arg4 = (int) 0 ;
46499 int arg5 = (int) 0 ;
46500 PyObject *arg6 = (PyObject *) NULL ;
46501 wxSizerItem *result = 0 ;
46502 void *argp1 = 0 ;
46503 int res1 = 0 ;
46504 int val3 ;
46505 int ecode3 = 0 ;
46506 int val4 ;
46507 int ecode4 = 0 ;
46508 int val5 ;
46509 int ecode5 = 0 ;
46510 PyObject * obj0 = 0 ;
46511 PyObject * obj1 = 0 ;
46512 PyObject * obj2 = 0 ;
46513 PyObject * obj3 = 0 ;
46514 PyObject * obj4 = 0 ;
46515 PyObject * obj5 = 0 ;
46516 char * kwnames[] = {
46517 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46518 };
46519
46520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46522 if (!SWIG_IsOK(res1)) {
46523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46524 }
46525 arg1 = reinterpret_cast< wxSizer * >(argp1);
46526 arg2 = obj1;
46527 if (obj2) {
46528 ecode3 = SWIG_AsVal_int(obj2, &val3);
46529 if (!SWIG_IsOK(ecode3)) {
46530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46531 }
46532 arg3 = static_cast< int >(val3);
46533 }
46534 if (obj3) {
46535 ecode4 = SWIG_AsVal_int(obj3, &val4);
46536 if (!SWIG_IsOK(ecode4)) {
46537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46538 }
46539 arg4 = static_cast< int >(val4);
46540 }
46541 if (obj4) {
46542 ecode5 = SWIG_AsVal_int(obj4, &val5);
46543 if (!SWIG_IsOK(ecode5)) {
46544 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46545 }
46546 arg5 = static_cast< int >(val5);
46547 }
46548 if (obj5) {
46549 arg6 = obj5;
46550 }
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46558 return resultobj;
46559 fail:
46560 return NULL;
46561 }
46562
46563
46564 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46565 PyObject *resultobj = 0;
46566 wxSizer *arg1 = (wxSizer *) 0 ;
46567 PyObject *arg2 = (PyObject *) 0 ;
46568 bool result;
46569 void *argp1 = 0 ;
46570 int res1 = 0 ;
46571 PyObject * obj0 = 0 ;
46572 PyObject * obj1 = 0 ;
46573 char * kwnames[] = {
46574 (char *) "self",(char *) "item", NULL
46575 };
46576
46577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46579 if (!SWIG_IsOK(res1)) {
46580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46581 }
46582 arg1 = reinterpret_cast< wxSizer * >(argp1);
46583 arg2 = obj1;
46584 {
46585 PyThreadState* __tstate = wxPyBeginAllowThreads();
46586 result = (bool)wxSizer_Remove(arg1,arg2);
46587 wxPyEndAllowThreads(__tstate);
46588 if (PyErr_Occurred()) SWIG_fail;
46589 }
46590 {
46591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46592 }
46593 return resultobj;
46594 fail:
46595 return NULL;
46596 }
46597
46598
46599 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46600 PyObject *resultobj = 0;
46601 wxSizer *arg1 = (wxSizer *) 0 ;
46602 PyObject *arg2 = (PyObject *) 0 ;
46603 bool result;
46604 void *argp1 = 0 ;
46605 int res1 = 0 ;
46606 PyObject * obj0 = 0 ;
46607 PyObject * obj1 = 0 ;
46608 char * kwnames[] = {
46609 (char *) "self",(char *) "item", NULL
46610 };
46611
46612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46614 if (!SWIG_IsOK(res1)) {
46615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46616 }
46617 arg1 = reinterpret_cast< wxSizer * >(argp1);
46618 arg2 = obj1;
46619 {
46620 PyThreadState* __tstate = wxPyBeginAllowThreads();
46621 result = (bool)wxSizer_Detach(arg1,arg2);
46622 wxPyEndAllowThreads(__tstate);
46623 if (PyErr_Occurred()) SWIG_fail;
46624 }
46625 {
46626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46627 }
46628 return resultobj;
46629 fail:
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46635 PyObject *resultobj = 0;
46636 wxSizer *arg1 = (wxSizer *) 0 ;
46637 PyObject *arg2 = (PyObject *) 0 ;
46638 wxSizerItem *result = 0 ;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "item", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46651 }
46652 arg1 = reinterpret_cast< wxSizer * >(argp1);
46653 arg2 = obj1;
46654 {
46655 PyThreadState* __tstate = wxPyBeginAllowThreads();
46656 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46657 wxPyEndAllowThreads(__tstate);
46658 if (PyErr_Occurred()) SWIG_fail;
46659 }
46660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46661 return resultobj;
46662 fail:
46663 return NULL;
46664 }
46665
46666
46667 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46668 PyObject *resultobj = 0;
46669 wxSizer *arg1 = (wxSizer *) 0 ;
46670 PyObject *arg2 = (PyObject *) 0 ;
46671 wxSize *arg3 = 0 ;
46672 void *argp1 = 0 ;
46673 int res1 = 0 ;
46674 wxSize temp3 ;
46675 PyObject * obj0 = 0 ;
46676 PyObject * obj1 = 0 ;
46677 PyObject * obj2 = 0 ;
46678 char * kwnames[] = {
46679 (char *) "self",(char *) "item",(char *) "size", NULL
46680 };
46681
46682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46686 }
46687 arg1 = reinterpret_cast< wxSizer * >(argp1);
46688 arg2 = obj1;
46689 {
46690 arg3 = &temp3;
46691 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46692 }
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_Py_Void();
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46707 PyObject *resultobj = 0;
46708 wxSizer *arg1 = (wxSizer *) 0 ;
46709 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46710 wxSizerItem *result = 0 ;
46711 void *argp1 = 0 ;
46712 int res1 = 0 ;
46713 int res2 = 0 ;
46714 PyObject * obj0 = 0 ;
46715 PyObject * obj1 = 0 ;
46716 char * kwnames[] = {
46717 (char *) "self",(char *) "item", NULL
46718 };
46719
46720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46722 if (!SWIG_IsOK(res1)) {
46723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46724 }
46725 arg1 = reinterpret_cast< wxSizer * >(argp1);
46726 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46727 if (!SWIG_IsOK(res2)) {
46728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46729 }
46730 {
46731 PyThreadState* __tstate = wxPyBeginAllowThreads();
46732 result = (wxSizerItem *)(arg1)->Add(arg2);
46733 wxPyEndAllowThreads(__tstate);
46734 if (PyErr_Occurred()) SWIG_fail;
46735 }
46736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46737 return resultobj;
46738 fail:
46739 return NULL;
46740 }
46741
46742
46743 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46744 PyObject *resultobj = 0;
46745 wxSizer *arg1 = (wxSizer *) 0 ;
46746 size_t arg2 ;
46747 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46748 wxSizerItem *result = 0 ;
46749 void *argp1 = 0 ;
46750 int res1 = 0 ;
46751 size_t val2 ;
46752 int ecode2 = 0 ;
46753 int res3 = 0 ;
46754 PyObject * obj0 = 0 ;
46755 PyObject * obj1 = 0 ;
46756 PyObject * obj2 = 0 ;
46757 char * kwnames[] = {
46758 (char *) "self",(char *) "index",(char *) "item", NULL
46759 };
46760
46761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46763 if (!SWIG_IsOK(res1)) {
46764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46765 }
46766 arg1 = reinterpret_cast< wxSizer * >(argp1);
46767 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46768 if (!SWIG_IsOK(ecode2)) {
46769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46770 }
46771 arg2 = static_cast< size_t >(val2);
46772 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46773 if (!SWIG_IsOK(res3)) {
46774 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46775 }
46776 {
46777 PyThreadState* __tstate = wxPyBeginAllowThreads();
46778 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46779 wxPyEndAllowThreads(__tstate);
46780 if (PyErr_Occurred()) SWIG_fail;
46781 }
46782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46783 return resultobj;
46784 fail:
46785 return NULL;
46786 }
46787
46788
46789 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46790 PyObject *resultobj = 0;
46791 wxSizer *arg1 = (wxSizer *) 0 ;
46792 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46793 wxSizerItem *result = 0 ;
46794 void *argp1 = 0 ;
46795 int res1 = 0 ;
46796 int res2 = 0 ;
46797 PyObject * obj0 = 0 ;
46798 PyObject * obj1 = 0 ;
46799 char * kwnames[] = {
46800 (char *) "self",(char *) "item", NULL
46801 };
46802
46803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46805 if (!SWIG_IsOK(res1)) {
46806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46807 }
46808 arg1 = reinterpret_cast< wxSizer * >(argp1);
46809 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46810 if (!SWIG_IsOK(res2)) {
46811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46812 }
46813 {
46814 PyThreadState* __tstate = wxPyBeginAllowThreads();
46815 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46816 wxPyEndAllowThreads(__tstate);
46817 if (PyErr_Occurred()) SWIG_fail;
46818 }
46819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46820 return resultobj;
46821 fail:
46822 return NULL;
46823 }
46824
46825
46826 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46827 PyObject *resultobj = 0;
46828 wxSizer *arg1 = (wxSizer *) 0 ;
46829 int arg2 ;
46830 int arg3 ;
46831 int arg4 ;
46832 int arg5 ;
46833 void *argp1 = 0 ;
46834 int res1 = 0 ;
46835 int val2 ;
46836 int ecode2 = 0 ;
46837 int val3 ;
46838 int ecode3 = 0 ;
46839 int val4 ;
46840 int ecode4 = 0 ;
46841 int val5 ;
46842 int ecode5 = 0 ;
46843 PyObject * obj0 = 0 ;
46844 PyObject * obj1 = 0 ;
46845 PyObject * obj2 = 0 ;
46846 PyObject * obj3 = 0 ;
46847 PyObject * obj4 = 0 ;
46848 char * kwnames[] = {
46849 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46850 };
46851
46852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46854 if (!SWIG_IsOK(res1)) {
46855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46856 }
46857 arg1 = reinterpret_cast< wxSizer * >(argp1);
46858 ecode2 = SWIG_AsVal_int(obj1, &val2);
46859 if (!SWIG_IsOK(ecode2)) {
46860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46861 }
46862 arg2 = static_cast< int >(val2);
46863 ecode3 = SWIG_AsVal_int(obj2, &val3);
46864 if (!SWIG_IsOK(ecode3)) {
46865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46866 }
46867 arg3 = static_cast< int >(val3);
46868 ecode4 = SWIG_AsVal_int(obj3, &val4);
46869 if (!SWIG_IsOK(ecode4)) {
46870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46871 }
46872 arg4 = static_cast< int >(val4);
46873 ecode5 = SWIG_AsVal_int(obj4, &val5);
46874 if (!SWIG_IsOK(ecode5)) {
46875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46876 }
46877 arg5 = static_cast< int >(val5);
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46881 wxPyEndAllowThreads(__tstate);
46882 if (PyErr_Occurred()) SWIG_fail;
46883 }
46884 resultobj = SWIG_Py_Void();
46885 return resultobj;
46886 fail:
46887 return NULL;
46888 }
46889
46890
46891 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46892 PyObject *resultobj = 0;
46893 wxSizer *arg1 = (wxSizer *) 0 ;
46894 wxSize *arg2 = 0 ;
46895 void *argp1 = 0 ;
46896 int res1 = 0 ;
46897 wxSize temp2 ;
46898 PyObject * obj0 = 0 ;
46899 PyObject * obj1 = 0 ;
46900 char * kwnames[] = {
46901 (char *) "self",(char *) "size", NULL
46902 };
46903
46904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46906 if (!SWIG_IsOK(res1)) {
46907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46908 }
46909 arg1 = reinterpret_cast< wxSizer * >(argp1);
46910 {
46911 arg2 = &temp2;
46912 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46913 }
46914 {
46915 PyThreadState* __tstate = wxPyBeginAllowThreads();
46916 (arg1)->SetMinSize((wxSize const &)*arg2);
46917 wxPyEndAllowThreads(__tstate);
46918 if (PyErr_Occurred()) SWIG_fail;
46919 }
46920 resultobj = SWIG_Py_Void();
46921 return resultobj;
46922 fail:
46923 return NULL;
46924 }
46925
46926
46927 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46928 PyObject *resultobj = 0;
46929 wxSizer *arg1 = (wxSizer *) 0 ;
46930 wxSize result;
46931 void *argp1 = 0 ;
46932 int res1 = 0 ;
46933 PyObject *swig_obj[1] ;
46934
46935 if (!args) SWIG_fail;
46936 swig_obj[0] = args;
46937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46938 if (!SWIG_IsOK(res1)) {
46939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46940 }
46941 arg1 = reinterpret_cast< wxSizer * >(argp1);
46942 {
46943 PyThreadState* __tstate = wxPyBeginAllowThreads();
46944 result = (arg1)->GetSize();
46945 wxPyEndAllowThreads(__tstate);
46946 if (PyErr_Occurred()) SWIG_fail;
46947 }
46948 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46949 return resultobj;
46950 fail:
46951 return NULL;
46952 }
46953
46954
46955 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46956 PyObject *resultobj = 0;
46957 wxSizer *arg1 = (wxSizer *) 0 ;
46958 wxPoint result;
46959 void *argp1 = 0 ;
46960 int res1 = 0 ;
46961 PyObject *swig_obj[1] ;
46962
46963 if (!args) SWIG_fail;
46964 swig_obj[0] = args;
46965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46966 if (!SWIG_IsOK(res1)) {
46967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46968 }
46969 arg1 = reinterpret_cast< wxSizer * >(argp1);
46970 {
46971 PyThreadState* __tstate = wxPyBeginAllowThreads();
46972 result = (arg1)->GetPosition();
46973 wxPyEndAllowThreads(__tstate);
46974 if (PyErr_Occurred()) SWIG_fail;
46975 }
46976 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46977 return resultobj;
46978 fail:
46979 return NULL;
46980 }
46981
46982
46983 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46984 PyObject *resultobj = 0;
46985 wxSizer *arg1 = (wxSizer *) 0 ;
46986 wxSize result;
46987 void *argp1 = 0 ;
46988 int res1 = 0 ;
46989 PyObject *swig_obj[1] ;
46990
46991 if (!args) SWIG_fail;
46992 swig_obj[0] = args;
46993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46996 }
46997 arg1 = reinterpret_cast< wxSizer * >(argp1);
46998 {
46999 PyThreadState* __tstate = wxPyBeginAllowThreads();
47000 result = (arg1)->GetMinSize();
47001 wxPyEndAllowThreads(__tstate);
47002 if (PyErr_Occurred()) SWIG_fail;
47003 }
47004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47005 return resultobj;
47006 fail:
47007 return NULL;
47008 }
47009
47010
47011 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47012 PyObject *resultobj = 0;
47013 wxSizer *arg1 = (wxSizer *) 0 ;
47014 void *argp1 = 0 ;
47015 int res1 = 0 ;
47016 PyObject *swig_obj[1] ;
47017
47018 if (!args) SWIG_fail;
47019 swig_obj[0] = args;
47020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47021 if (!SWIG_IsOK(res1)) {
47022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47023 }
47024 arg1 = reinterpret_cast< wxSizer * >(argp1);
47025 {
47026 PyThreadState* __tstate = wxPyBeginAllowThreads();
47027 (arg1)->RecalcSizes();
47028 wxPyEndAllowThreads(__tstate);
47029 if (PyErr_Occurred()) SWIG_fail;
47030 }
47031 resultobj = SWIG_Py_Void();
47032 return resultobj;
47033 fail:
47034 return NULL;
47035 }
47036
47037
47038 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47039 PyObject *resultobj = 0;
47040 wxSizer *arg1 = (wxSizer *) 0 ;
47041 wxSize result;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 PyObject *swig_obj[1] ;
47045
47046 if (!args) SWIG_fail;
47047 swig_obj[0] = args;
47048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47049 if (!SWIG_IsOK(res1)) {
47050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47051 }
47052 arg1 = reinterpret_cast< wxSizer * >(argp1);
47053 {
47054 PyThreadState* __tstate = wxPyBeginAllowThreads();
47055 result = (arg1)->CalcMin();
47056 wxPyEndAllowThreads(__tstate);
47057 if (PyErr_Occurred()) SWIG_fail;
47058 }
47059 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47060 return resultobj;
47061 fail:
47062 return NULL;
47063 }
47064
47065
47066 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47067 PyObject *resultobj = 0;
47068 wxSizer *arg1 = (wxSizer *) 0 ;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 PyObject *swig_obj[1] ;
47072
47073 if (!args) SWIG_fail;
47074 swig_obj[0] = args;
47075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizer * >(argp1);
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 (arg1)->Layout();
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 resultobj = SWIG_Py_Void();
47087 return resultobj;
47088 fail:
47089 return NULL;
47090 }
47091
47092
47093 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxSizer *arg1 = (wxSizer *) 0 ;
47096 wxWindow *arg2 = (wxWindow *) 0 ;
47097 wxSize result;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 void *argp2 = 0 ;
47101 int res2 = 0 ;
47102 PyObject * obj0 = 0 ;
47103 PyObject * obj1 = 0 ;
47104 char * kwnames[] = {
47105 (char *) "self",(char *) "window", NULL
47106 };
47107
47108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47110 if (!SWIG_IsOK(res1)) {
47111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47112 }
47113 arg1 = reinterpret_cast< wxSizer * >(argp1);
47114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47115 if (!SWIG_IsOK(res2)) {
47116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47117 }
47118 arg2 = reinterpret_cast< wxWindow * >(argp2);
47119 {
47120 PyThreadState* __tstate = wxPyBeginAllowThreads();
47121 result = (arg1)->Fit(arg2);
47122 wxPyEndAllowThreads(__tstate);
47123 if (PyErr_Occurred()) SWIG_fail;
47124 }
47125 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47126 return resultobj;
47127 fail:
47128 return NULL;
47129 }
47130
47131
47132 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47133 PyObject *resultobj = 0;
47134 wxSizer *arg1 = (wxSizer *) 0 ;
47135 wxWindow *arg2 = (wxWindow *) 0 ;
47136 void *argp1 = 0 ;
47137 int res1 = 0 ;
47138 void *argp2 = 0 ;
47139 int res2 = 0 ;
47140 PyObject * obj0 = 0 ;
47141 PyObject * obj1 = 0 ;
47142 char * kwnames[] = {
47143 (char *) "self",(char *) "window", NULL
47144 };
47145
47146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47148 if (!SWIG_IsOK(res1)) {
47149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47150 }
47151 arg1 = reinterpret_cast< wxSizer * >(argp1);
47152 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47153 if (!SWIG_IsOK(res2)) {
47154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47155 }
47156 arg2 = reinterpret_cast< wxWindow * >(argp2);
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 (arg1)->FitInside(arg2);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 resultobj = SWIG_Py_Void();
47164 return resultobj;
47165 fail:
47166 return NULL;
47167 }
47168
47169
47170 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47171 PyObject *resultobj = 0;
47172 wxSizer *arg1 = (wxSizer *) 0 ;
47173 wxWindow *arg2 = (wxWindow *) 0 ;
47174 void *argp1 = 0 ;
47175 int res1 = 0 ;
47176 void *argp2 = 0 ;
47177 int res2 = 0 ;
47178 PyObject * obj0 = 0 ;
47179 PyObject * obj1 = 0 ;
47180 char * kwnames[] = {
47181 (char *) "self",(char *) "window", NULL
47182 };
47183
47184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47186 if (!SWIG_IsOK(res1)) {
47187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47188 }
47189 arg1 = reinterpret_cast< wxSizer * >(argp1);
47190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47191 if (!SWIG_IsOK(res2)) {
47192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47193 }
47194 arg2 = reinterpret_cast< wxWindow * >(argp2);
47195 {
47196 PyThreadState* __tstate = wxPyBeginAllowThreads();
47197 (arg1)->SetSizeHints(arg2);
47198 wxPyEndAllowThreads(__tstate);
47199 if (PyErr_Occurred()) SWIG_fail;
47200 }
47201 resultobj = SWIG_Py_Void();
47202 return resultobj;
47203 fail:
47204 return NULL;
47205 }
47206
47207
47208 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47209 PyObject *resultobj = 0;
47210 wxSizer *arg1 = (wxSizer *) 0 ;
47211 wxWindow *arg2 = (wxWindow *) 0 ;
47212 void *argp1 = 0 ;
47213 int res1 = 0 ;
47214 void *argp2 = 0 ;
47215 int res2 = 0 ;
47216 PyObject * obj0 = 0 ;
47217 PyObject * obj1 = 0 ;
47218 char * kwnames[] = {
47219 (char *) "self",(char *) "window", NULL
47220 };
47221
47222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47224 if (!SWIG_IsOK(res1)) {
47225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47226 }
47227 arg1 = reinterpret_cast< wxSizer * >(argp1);
47228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47229 if (!SWIG_IsOK(res2)) {
47230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47231 }
47232 arg2 = reinterpret_cast< wxWindow * >(argp2);
47233 {
47234 PyThreadState* __tstate = wxPyBeginAllowThreads();
47235 (arg1)->SetVirtualSizeHints(arg2);
47236 wxPyEndAllowThreads(__tstate);
47237 if (PyErr_Occurred()) SWIG_fail;
47238 }
47239 resultobj = SWIG_Py_Void();
47240 return resultobj;
47241 fail:
47242 return NULL;
47243 }
47244
47245
47246 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47247 PyObject *resultobj = 0;
47248 wxSizer *arg1 = (wxSizer *) 0 ;
47249 bool arg2 = (bool) false ;
47250 void *argp1 = 0 ;
47251 int res1 = 0 ;
47252 bool val2 ;
47253 int ecode2 = 0 ;
47254 PyObject * obj0 = 0 ;
47255 PyObject * obj1 = 0 ;
47256 char * kwnames[] = {
47257 (char *) "self",(char *) "deleteWindows", NULL
47258 };
47259
47260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47262 if (!SWIG_IsOK(res1)) {
47263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47264 }
47265 arg1 = reinterpret_cast< wxSizer * >(argp1);
47266 if (obj1) {
47267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47268 if (!SWIG_IsOK(ecode2)) {
47269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47270 }
47271 arg2 = static_cast< bool >(val2);
47272 }
47273 {
47274 PyThreadState* __tstate = wxPyBeginAllowThreads();
47275 (arg1)->Clear(arg2);
47276 wxPyEndAllowThreads(__tstate);
47277 if (PyErr_Occurred()) SWIG_fail;
47278 }
47279 resultobj = SWIG_Py_Void();
47280 return resultobj;
47281 fail:
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 wxSizer *arg1 = (wxSizer *) 0 ;
47289 void *argp1 = 0 ;
47290 int res1 = 0 ;
47291 PyObject *swig_obj[1] ;
47292
47293 if (!args) SWIG_fail;
47294 swig_obj[0] = args;
47295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47298 }
47299 arg1 = reinterpret_cast< wxSizer * >(argp1);
47300 {
47301 PyThreadState* __tstate = wxPyBeginAllowThreads();
47302 (arg1)->DeleteWindows();
47303 wxPyEndAllowThreads(__tstate);
47304 if (PyErr_Occurred()) SWIG_fail;
47305 }
47306 resultobj = SWIG_Py_Void();
47307 return resultobj;
47308 fail:
47309 return NULL;
47310 }
47311
47312
47313 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47314 PyObject *resultobj = 0;
47315 wxSizer *arg1 = (wxSizer *) 0 ;
47316 PyObject *result = 0 ;
47317 void *argp1 = 0 ;
47318 int res1 = 0 ;
47319 PyObject *swig_obj[1] ;
47320
47321 if (!args) SWIG_fail;
47322 swig_obj[0] = args;
47323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47324 if (!SWIG_IsOK(res1)) {
47325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47326 }
47327 arg1 = reinterpret_cast< wxSizer * >(argp1);
47328 {
47329 PyThreadState* __tstate = wxPyBeginAllowThreads();
47330 result = (PyObject *)wxSizer_GetChildren(arg1);
47331 wxPyEndAllowThreads(__tstate);
47332 if (PyErr_Occurred()) SWIG_fail;
47333 }
47334 resultobj = result;
47335 return resultobj;
47336 fail:
47337 return NULL;
47338 }
47339
47340
47341 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47342 PyObject *resultobj = 0;
47343 wxSizer *arg1 = (wxSizer *) 0 ;
47344 PyObject *arg2 = (PyObject *) 0 ;
47345 bool arg3 = (bool) true ;
47346 bool arg4 = (bool) false ;
47347 bool result;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 bool val3 ;
47351 int ecode3 = 0 ;
47352 bool val4 ;
47353 int ecode4 = 0 ;
47354 PyObject * obj0 = 0 ;
47355 PyObject * obj1 = 0 ;
47356 PyObject * obj2 = 0 ;
47357 PyObject * obj3 = 0 ;
47358 char * kwnames[] = {
47359 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47360 };
47361
47362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47364 if (!SWIG_IsOK(res1)) {
47365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47366 }
47367 arg1 = reinterpret_cast< wxSizer * >(argp1);
47368 arg2 = obj1;
47369 if (obj2) {
47370 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47371 if (!SWIG_IsOK(ecode3)) {
47372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47373 }
47374 arg3 = static_cast< bool >(val3);
47375 }
47376 if (obj3) {
47377 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47378 if (!SWIG_IsOK(ecode4)) {
47379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47380 }
47381 arg4 = static_cast< bool >(val4);
47382 }
47383 {
47384 PyThreadState* __tstate = wxPyBeginAllowThreads();
47385 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47386 wxPyEndAllowThreads(__tstate);
47387 if (PyErr_Occurred()) SWIG_fail;
47388 }
47389 {
47390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47391 }
47392 return resultobj;
47393 fail:
47394 return NULL;
47395 }
47396
47397
47398 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47399 PyObject *resultobj = 0;
47400 wxSizer *arg1 = (wxSizer *) 0 ;
47401 PyObject *arg2 = (PyObject *) 0 ;
47402 bool result;
47403 void *argp1 = 0 ;
47404 int res1 = 0 ;
47405 PyObject * obj0 = 0 ;
47406 PyObject * obj1 = 0 ;
47407 char * kwnames[] = {
47408 (char *) "self",(char *) "item", NULL
47409 };
47410
47411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47413 if (!SWIG_IsOK(res1)) {
47414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47415 }
47416 arg1 = reinterpret_cast< wxSizer * >(argp1);
47417 arg2 = obj1;
47418 {
47419 PyThreadState* __tstate = wxPyBeginAllowThreads();
47420 result = (bool)wxSizer_IsShown(arg1,arg2);
47421 wxPyEndAllowThreads(__tstate);
47422 if (PyErr_Occurred()) SWIG_fail;
47423 }
47424 {
47425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47426 }
47427 return resultobj;
47428 fail:
47429 return NULL;
47430 }
47431
47432
47433 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47434 PyObject *resultobj = 0;
47435 wxSizer *arg1 = (wxSizer *) 0 ;
47436 bool arg2 ;
47437 void *argp1 = 0 ;
47438 int res1 = 0 ;
47439 bool val2 ;
47440 int ecode2 = 0 ;
47441 PyObject * obj0 = 0 ;
47442 PyObject * obj1 = 0 ;
47443 char * kwnames[] = {
47444 (char *) "self",(char *) "show", NULL
47445 };
47446
47447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47449 if (!SWIG_IsOK(res1)) {
47450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47451 }
47452 arg1 = reinterpret_cast< wxSizer * >(argp1);
47453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47454 if (!SWIG_IsOK(ecode2)) {
47455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47456 }
47457 arg2 = static_cast< bool >(val2);
47458 {
47459 PyThreadState* __tstate = wxPyBeginAllowThreads();
47460 (arg1)->ShowItems(arg2);
47461 wxPyEndAllowThreads(__tstate);
47462 if (PyErr_Occurred()) SWIG_fail;
47463 }
47464 resultobj = SWIG_Py_Void();
47465 return resultobj;
47466 fail:
47467 return NULL;
47468 }
47469
47470
47471 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47472 PyObject *obj;
47473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47474 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47475 return SWIG_Py_Void();
47476 }
47477
47478 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47479 PyObject *resultobj = 0;
47480 wxPySizer *result = 0 ;
47481
47482 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47483 {
47484 PyThreadState* __tstate = wxPyBeginAllowThreads();
47485 result = (wxPySizer *)new wxPySizer();
47486 wxPyEndAllowThreads(__tstate);
47487 if (PyErr_Occurred()) SWIG_fail;
47488 }
47489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47490 return resultobj;
47491 fail:
47492 return NULL;
47493 }
47494
47495
47496 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47497 PyObject *resultobj = 0;
47498 wxPySizer *arg1 = (wxPySizer *) 0 ;
47499 PyObject *arg2 = (PyObject *) 0 ;
47500 PyObject *arg3 = (PyObject *) 0 ;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 PyObject * obj0 = 0 ;
47504 PyObject * obj1 = 0 ;
47505 PyObject * obj2 = 0 ;
47506 char * kwnames[] = {
47507 (char *) "self",(char *) "self",(char *) "_class", NULL
47508 };
47509
47510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47512 if (!SWIG_IsOK(res1)) {
47513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47514 }
47515 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47516 arg2 = obj1;
47517 arg3 = obj2;
47518 {
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 (arg1)->_setCallbackInfo(arg2,arg3);
47521 wxPyEndAllowThreads(__tstate);
47522 if (PyErr_Occurred()) SWIG_fail;
47523 }
47524 resultobj = SWIG_Py_Void();
47525 return resultobj;
47526 fail:
47527 return NULL;
47528 }
47529
47530
47531 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47532 PyObject *obj;
47533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47534 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47535 return SWIG_Py_Void();
47536 }
47537
47538 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47539 return SWIG_Python_InitShadowInstance(args);
47540 }
47541
47542 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47543 PyObject *resultobj = 0;
47544 int arg1 = (int) wxHORIZONTAL ;
47545 wxBoxSizer *result = 0 ;
47546 int val1 ;
47547 int ecode1 = 0 ;
47548 PyObject * obj0 = 0 ;
47549 char * kwnames[] = {
47550 (char *) "orient", NULL
47551 };
47552
47553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47554 if (obj0) {
47555 ecode1 = SWIG_AsVal_int(obj0, &val1);
47556 if (!SWIG_IsOK(ecode1)) {
47557 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47558 }
47559 arg1 = static_cast< int >(val1);
47560 }
47561 {
47562 PyThreadState* __tstate = wxPyBeginAllowThreads();
47563 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47564 wxPyEndAllowThreads(__tstate);
47565 if (PyErr_Occurred()) SWIG_fail;
47566 }
47567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47568 return resultobj;
47569 fail:
47570 return NULL;
47571 }
47572
47573
47574 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47575 PyObject *resultobj = 0;
47576 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47577 int result;
47578 void *argp1 = 0 ;
47579 int res1 = 0 ;
47580 PyObject *swig_obj[1] ;
47581
47582 if (!args) SWIG_fail;
47583 swig_obj[0] = args;
47584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47585 if (!SWIG_IsOK(res1)) {
47586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47587 }
47588 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47589 {
47590 PyThreadState* __tstate = wxPyBeginAllowThreads();
47591 result = (int)(arg1)->GetOrientation();
47592 wxPyEndAllowThreads(__tstate);
47593 if (PyErr_Occurred()) SWIG_fail;
47594 }
47595 resultobj = SWIG_From_int(static_cast< int >(result));
47596 return resultobj;
47597 fail:
47598 return NULL;
47599 }
47600
47601
47602 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47603 PyObject *resultobj = 0;
47604 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47605 int arg2 ;
47606 void *argp1 = 0 ;
47607 int res1 = 0 ;
47608 int val2 ;
47609 int ecode2 = 0 ;
47610 PyObject * obj0 = 0 ;
47611 PyObject * obj1 = 0 ;
47612 char * kwnames[] = {
47613 (char *) "self",(char *) "orient", NULL
47614 };
47615
47616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47618 if (!SWIG_IsOK(res1)) {
47619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47620 }
47621 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47622 ecode2 = SWIG_AsVal_int(obj1, &val2);
47623 if (!SWIG_IsOK(ecode2)) {
47624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47625 }
47626 arg2 = static_cast< int >(val2);
47627 {
47628 PyThreadState* __tstate = wxPyBeginAllowThreads();
47629 (arg1)->SetOrientation(arg2);
47630 wxPyEndAllowThreads(__tstate);
47631 if (PyErr_Occurred()) SWIG_fail;
47632 }
47633 resultobj = SWIG_Py_Void();
47634 return resultobj;
47635 fail:
47636 return NULL;
47637 }
47638
47639
47640 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 PyObject *obj;
47642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47643 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47644 return SWIG_Py_Void();
47645 }
47646
47647 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47648 return SWIG_Python_InitShadowInstance(args);
47649 }
47650
47651 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47652 PyObject *resultobj = 0;
47653 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47654 int arg2 = (int) wxHORIZONTAL ;
47655 wxStaticBoxSizer *result = 0 ;
47656 void *argp1 = 0 ;
47657 int res1 = 0 ;
47658 int val2 ;
47659 int ecode2 = 0 ;
47660 PyObject * obj0 = 0 ;
47661 PyObject * obj1 = 0 ;
47662 char * kwnames[] = {
47663 (char *) "box",(char *) "orient", NULL
47664 };
47665
47666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47668 if (!SWIG_IsOK(res1)) {
47669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47670 }
47671 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47672 if (obj1) {
47673 ecode2 = SWIG_AsVal_int(obj1, &val2);
47674 if (!SWIG_IsOK(ecode2)) {
47675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47676 }
47677 arg2 = static_cast< int >(val2);
47678 }
47679 {
47680 PyThreadState* __tstate = wxPyBeginAllowThreads();
47681 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47682 wxPyEndAllowThreads(__tstate);
47683 if (PyErr_Occurred()) SWIG_fail;
47684 }
47685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47686 return resultobj;
47687 fail:
47688 return NULL;
47689 }
47690
47691
47692 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47693 PyObject *resultobj = 0;
47694 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47695 wxStaticBox *result = 0 ;
47696 void *argp1 = 0 ;
47697 int res1 = 0 ;
47698 PyObject *swig_obj[1] ;
47699
47700 if (!args) SWIG_fail;
47701 swig_obj[0] = args;
47702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47703 if (!SWIG_IsOK(res1)) {
47704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47705 }
47706 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47707 {
47708 PyThreadState* __tstate = wxPyBeginAllowThreads();
47709 result = (wxStaticBox *)(arg1)->GetStaticBox();
47710 wxPyEndAllowThreads(__tstate);
47711 if (PyErr_Occurred()) SWIG_fail;
47712 }
47713 {
47714 resultobj = wxPyMake_wxObject(result, (bool)0);
47715 }
47716 return resultobj;
47717 fail:
47718 return NULL;
47719 }
47720
47721
47722 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47723 PyObject *obj;
47724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47725 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47726 return SWIG_Py_Void();
47727 }
47728
47729 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47730 return SWIG_Python_InitShadowInstance(args);
47731 }
47732
47733 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47734 PyObject *resultobj = 0;
47735 int arg1 = (int) 1 ;
47736 int arg2 = (int) 0 ;
47737 int arg3 = (int) 0 ;
47738 int arg4 = (int) 0 ;
47739 wxGridSizer *result = 0 ;
47740 int val1 ;
47741 int ecode1 = 0 ;
47742 int val2 ;
47743 int ecode2 = 0 ;
47744 int val3 ;
47745 int ecode3 = 0 ;
47746 int val4 ;
47747 int ecode4 = 0 ;
47748 PyObject * obj0 = 0 ;
47749 PyObject * obj1 = 0 ;
47750 PyObject * obj2 = 0 ;
47751 PyObject * obj3 = 0 ;
47752 char * kwnames[] = {
47753 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47754 };
47755
47756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47757 if (obj0) {
47758 ecode1 = SWIG_AsVal_int(obj0, &val1);
47759 if (!SWIG_IsOK(ecode1)) {
47760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47761 }
47762 arg1 = static_cast< int >(val1);
47763 }
47764 if (obj1) {
47765 ecode2 = SWIG_AsVal_int(obj1, &val2);
47766 if (!SWIG_IsOK(ecode2)) {
47767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47768 }
47769 arg2 = static_cast< int >(val2);
47770 }
47771 if (obj2) {
47772 ecode3 = SWIG_AsVal_int(obj2, &val3);
47773 if (!SWIG_IsOK(ecode3)) {
47774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47775 }
47776 arg3 = static_cast< int >(val3);
47777 }
47778 if (obj3) {
47779 ecode4 = SWIG_AsVal_int(obj3, &val4);
47780 if (!SWIG_IsOK(ecode4)) {
47781 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47782 }
47783 arg4 = static_cast< int >(val4);
47784 }
47785 {
47786 PyThreadState* __tstate = wxPyBeginAllowThreads();
47787 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47788 wxPyEndAllowThreads(__tstate);
47789 if (PyErr_Occurred()) SWIG_fail;
47790 }
47791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47792 return resultobj;
47793 fail:
47794 return NULL;
47795 }
47796
47797
47798 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47799 PyObject *resultobj = 0;
47800 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47801 int arg2 ;
47802 void *argp1 = 0 ;
47803 int res1 = 0 ;
47804 int val2 ;
47805 int ecode2 = 0 ;
47806 PyObject * obj0 = 0 ;
47807 PyObject * obj1 = 0 ;
47808 char * kwnames[] = {
47809 (char *) "self",(char *) "cols", NULL
47810 };
47811
47812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47814 if (!SWIG_IsOK(res1)) {
47815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47816 }
47817 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47818 ecode2 = SWIG_AsVal_int(obj1, &val2);
47819 if (!SWIG_IsOK(ecode2)) {
47820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47821 }
47822 arg2 = static_cast< int >(val2);
47823 {
47824 PyThreadState* __tstate = wxPyBeginAllowThreads();
47825 (arg1)->SetCols(arg2);
47826 wxPyEndAllowThreads(__tstate);
47827 if (PyErr_Occurred()) SWIG_fail;
47828 }
47829 resultobj = SWIG_Py_Void();
47830 return resultobj;
47831 fail:
47832 return NULL;
47833 }
47834
47835
47836 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47837 PyObject *resultobj = 0;
47838 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47839 int arg2 ;
47840 void *argp1 = 0 ;
47841 int res1 = 0 ;
47842 int val2 ;
47843 int ecode2 = 0 ;
47844 PyObject * obj0 = 0 ;
47845 PyObject * obj1 = 0 ;
47846 char * kwnames[] = {
47847 (char *) "self",(char *) "rows", NULL
47848 };
47849
47850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47852 if (!SWIG_IsOK(res1)) {
47853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47854 }
47855 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47856 ecode2 = SWIG_AsVal_int(obj1, &val2);
47857 if (!SWIG_IsOK(ecode2)) {
47858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47859 }
47860 arg2 = static_cast< int >(val2);
47861 {
47862 PyThreadState* __tstate = wxPyBeginAllowThreads();
47863 (arg1)->SetRows(arg2);
47864 wxPyEndAllowThreads(__tstate);
47865 if (PyErr_Occurred()) SWIG_fail;
47866 }
47867 resultobj = SWIG_Py_Void();
47868 return resultobj;
47869 fail:
47870 return NULL;
47871 }
47872
47873
47874 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47875 PyObject *resultobj = 0;
47876 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47877 int arg2 ;
47878 void *argp1 = 0 ;
47879 int res1 = 0 ;
47880 int val2 ;
47881 int ecode2 = 0 ;
47882 PyObject * obj0 = 0 ;
47883 PyObject * obj1 = 0 ;
47884 char * kwnames[] = {
47885 (char *) "self",(char *) "gap", NULL
47886 };
47887
47888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47890 if (!SWIG_IsOK(res1)) {
47891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47892 }
47893 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47894 ecode2 = SWIG_AsVal_int(obj1, &val2);
47895 if (!SWIG_IsOK(ecode2)) {
47896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47897 }
47898 arg2 = static_cast< int >(val2);
47899 {
47900 PyThreadState* __tstate = wxPyBeginAllowThreads();
47901 (arg1)->SetVGap(arg2);
47902 wxPyEndAllowThreads(__tstate);
47903 if (PyErr_Occurred()) SWIG_fail;
47904 }
47905 resultobj = SWIG_Py_Void();
47906 return resultobj;
47907 fail:
47908 return NULL;
47909 }
47910
47911
47912 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47913 PyObject *resultobj = 0;
47914 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47915 int arg2 ;
47916 void *argp1 = 0 ;
47917 int res1 = 0 ;
47918 int val2 ;
47919 int ecode2 = 0 ;
47920 PyObject * obj0 = 0 ;
47921 PyObject * obj1 = 0 ;
47922 char * kwnames[] = {
47923 (char *) "self",(char *) "gap", NULL
47924 };
47925
47926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47928 if (!SWIG_IsOK(res1)) {
47929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47930 }
47931 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47932 ecode2 = SWIG_AsVal_int(obj1, &val2);
47933 if (!SWIG_IsOK(ecode2)) {
47934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47935 }
47936 arg2 = static_cast< int >(val2);
47937 {
47938 PyThreadState* __tstate = wxPyBeginAllowThreads();
47939 (arg1)->SetHGap(arg2);
47940 wxPyEndAllowThreads(__tstate);
47941 if (PyErr_Occurred()) SWIG_fail;
47942 }
47943 resultobj = SWIG_Py_Void();
47944 return resultobj;
47945 fail:
47946 return NULL;
47947 }
47948
47949
47950 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47951 PyObject *resultobj = 0;
47952 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47953 int result;
47954 void *argp1 = 0 ;
47955 int res1 = 0 ;
47956 PyObject *swig_obj[1] ;
47957
47958 if (!args) SWIG_fail;
47959 swig_obj[0] = args;
47960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47961 if (!SWIG_IsOK(res1)) {
47962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47963 }
47964 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 result = (int)(arg1)->GetCols();
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 resultobj = SWIG_From_int(static_cast< int >(result));
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47979 PyObject *resultobj = 0;
47980 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47981 int result;
47982 void *argp1 = 0 ;
47983 int res1 = 0 ;
47984 PyObject *swig_obj[1] ;
47985
47986 if (!args) SWIG_fail;
47987 swig_obj[0] = args;
47988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47989 if (!SWIG_IsOK(res1)) {
47990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47991 }
47992 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47993 {
47994 PyThreadState* __tstate = wxPyBeginAllowThreads();
47995 result = (int)(arg1)->GetRows();
47996 wxPyEndAllowThreads(__tstate);
47997 if (PyErr_Occurred()) SWIG_fail;
47998 }
47999 resultobj = SWIG_From_int(static_cast< int >(result));
48000 return resultobj;
48001 fail:
48002 return NULL;
48003 }
48004
48005
48006 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48007 PyObject *resultobj = 0;
48008 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48009 int result;
48010 void *argp1 = 0 ;
48011 int res1 = 0 ;
48012 PyObject *swig_obj[1] ;
48013
48014 if (!args) SWIG_fail;
48015 swig_obj[0] = args;
48016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48017 if (!SWIG_IsOK(res1)) {
48018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48019 }
48020 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48021 {
48022 PyThreadState* __tstate = wxPyBeginAllowThreads();
48023 result = (int)(arg1)->GetVGap();
48024 wxPyEndAllowThreads(__tstate);
48025 if (PyErr_Occurred()) SWIG_fail;
48026 }
48027 resultobj = SWIG_From_int(static_cast< int >(result));
48028 return resultobj;
48029 fail:
48030 return NULL;
48031 }
48032
48033
48034 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48035 PyObject *resultobj = 0;
48036 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48037 int result;
48038 void *argp1 = 0 ;
48039 int res1 = 0 ;
48040 PyObject *swig_obj[1] ;
48041
48042 if (!args) SWIG_fail;
48043 swig_obj[0] = args;
48044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48045 if (!SWIG_IsOK(res1)) {
48046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48047 }
48048 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48049 {
48050 PyThreadState* __tstate = wxPyBeginAllowThreads();
48051 result = (int)(arg1)->GetHGap();
48052 wxPyEndAllowThreads(__tstate);
48053 if (PyErr_Occurred()) SWIG_fail;
48054 }
48055 resultobj = SWIG_From_int(static_cast< int >(result));
48056 return resultobj;
48057 fail:
48058 return NULL;
48059 }
48060
48061
48062 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48063 PyObject *obj;
48064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48065 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48066 return SWIG_Py_Void();
48067 }
48068
48069 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48070 return SWIG_Python_InitShadowInstance(args);
48071 }
48072
48073 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48074 PyObject *resultobj = 0;
48075 int arg1 = (int) 1 ;
48076 int arg2 = (int) 0 ;
48077 int arg3 = (int) 0 ;
48078 int arg4 = (int) 0 ;
48079 wxFlexGridSizer *result = 0 ;
48080 int val1 ;
48081 int ecode1 = 0 ;
48082 int val2 ;
48083 int ecode2 = 0 ;
48084 int val3 ;
48085 int ecode3 = 0 ;
48086 int val4 ;
48087 int ecode4 = 0 ;
48088 PyObject * obj0 = 0 ;
48089 PyObject * obj1 = 0 ;
48090 PyObject * obj2 = 0 ;
48091 PyObject * obj3 = 0 ;
48092 char * kwnames[] = {
48093 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48094 };
48095
48096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48097 if (obj0) {
48098 ecode1 = SWIG_AsVal_int(obj0, &val1);
48099 if (!SWIG_IsOK(ecode1)) {
48100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48101 }
48102 arg1 = static_cast< int >(val1);
48103 }
48104 if (obj1) {
48105 ecode2 = SWIG_AsVal_int(obj1, &val2);
48106 if (!SWIG_IsOK(ecode2)) {
48107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48108 }
48109 arg2 = static_cast< int >(val2);
48110 }
48111 if (obj2) {
48112 ecode3 = SWIG_AsVal_int(obj2, &val3);
48113 if (!SWIG_IsOK(ecode3)) {
48114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48115 }
48116 arg3 = static_cast< int >(val3);
48117 }
48118 if (obj3) {
48119 ecode4 = SWIG_AsVal_int(obj3, &val4);
48120 if (!SWIG_IsOK(ecode4)) {
48121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48122 }
48123 arg4 = static_cast< int >(val4);
48124 }
48125 {
48126 PyThreadState* __tstate = wxPyBeginAllowThreads();
48127 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48128 wxPyEndAllowThreads(__tstate);
48129 if (PyErr_Occurred()) SWIG_fail;
48130 }
48131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48132 return resultobj;
48133 fail:
48134 return NULL;
48135 }
48136
48137
48138 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48139 PyObject *resultobj = 0;
48140 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48141 size_t arg2 ;
48142 int arg3 = (int) 0 ;
48143 void *argp1 = 0 ;
48144 int res1 = 0 ;
48145 size_t val2 ;
48146 int ecode2 = 0 ;
48147 int val3 ;
48148 int ecode3 = 0 ;
48149 PyObject * obj0 = 0 ;
48150 PyObject * obj1 = 0 ;
48151 PyObject * obj2 = 0 ;
48152 char * kwnames[] = {
48153 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48154 };
48155
48156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48158 if (!SWIG_IsOK(res1)) {
48159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48160 }
48161 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48162 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48163 if (!SWIG_IsOK(ecode2)) {
48164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48165 }
48166 arg2 = static_cast< size_t >(val2);
48167 if (obj2) {
48168 ecode3 = SWIG_AsVal_int(obj2, &val3);
48169 if (!SWIG_IsOK(ecode3)) {
48170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48171 }
48172 arg3 = static_cast< int >(val3);
48173 }
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 (arg1)->AddGrowableRow(arg2,arg3);
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_Py_Void();
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48188 PyObject *resultobj = 0;
48189 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48190 size_t arg2 ;
48191 void *argp1 = 0 ;
48192 int res1 = 0 ;
48193 size_t val2 ;
48194 int ecode2 = 0 ;
48195 PyObject * obj0 = 0 ;
48196 PyObject * obj1 = 0 ;
48197 char * kwnames[] = {
48198 (char *) "self",(char *) "idx", NULL
48199 };
48200
48201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48203 if (!SWIG_IsOK(res1)) {
48204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48205 }
48206 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48207 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48208 if (!SWIG_IsOK(ecode2)) {
48209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48210 }
48211 arg2 = static_cast< size_t >(val2);
48212 {
48213 PyThreadState* __tstate = wxPyBeginAllowThreads();
48214 (arg1)->RemoveGrowableRow(arg2);
48215 wxPyEndAllowThreads(__tstate);
48216 if (PyErr_Occurred()) SWIG_fail;
48217 }
48218 resultobj = SWIG_Py_Void();
48219 return resultobj;
48220 fail:
48221 return NULL;
48222 }
48223
48224
48225 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48226 PyObject *resultobj = 0;
48227 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48228 size_t arg2 ;
48229 int arg3 = (int) 0 ;
48230 void *argp1 = 0 ;
48231 int res1 = 0 ;
48232 size_t val2 ;
48233 int ecode2 = 0 ;
48234 int val3 ;
48235 int ecode3 = 0 ;
48236 PyObject * obj0 = 0 ;
48237 PyObject * obj1 = 0 ;
48238 PyObject * obj2 = 0 ;
48239 char * kwnames[] = {
48240 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48241 };
48242
48243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48245 if (!SWIG_IsOK(res1)) {
48246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48247 }
48248 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48249 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48250 if (!SWIG_IsOK(ecode2)) {
48251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48252 }
48253 arg2 = static_cast< size_t >(val2);
48254 if (obj2) {
48255 ecode3 = SWIG_AsVal_int(obj2, &val3);
48256 if (!SWIG_IsOK(ecode3)) {
48257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48258 }
48259 arg3 = static_cast< int >(val3);
48260 }
48261 {
48262 PyThreadState* __tstate = wxPyBeginAllowThreads();
48263 (arg1)->AddGrowableCol(arg2,arg3);
48264 wxPyEndAllowThreads(__tstate);
48265 if (PyErr_Occurred()) SWIG_fail;
48266 }
48267 resultobj = SWIG_Py_Void();
48268 return resultobj;
48269 fail:
48270 return NULL;
48271 }
48272
48273
48274 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48275 PyObject *resultobj = 0;
48276 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48277 size_t arg2 ;
48278 void *argp1 = 0 ;
48279 int res1 = 0 ;
48280 size_t val2 ;
48281 int ecode2 = 0 ;
48282 PyObject * obj0 = 0 ;
48283 PyObject * obj1 = 0 ;
48284 char * kwnames[] = {
48285 (char *) "self",(char *) "idx", NULL
48286 };
48287
48288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48290 if (!SWIG_IsOK(res1)) {
48291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48292 }
48293 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48294 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48295 if (!SWIG_IsOK(ecode2)) {
48296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48297 }
48298 arg2 = static_cast< size_t >(val2);
48299 {
48300 PyThreadState* __tstate = wxPyBeginAllowThreads();
48301 (arg1)->RemoveGrowableCol(arg2);
48302 wxPyEndAllowThreads(__tstate);
48303 if (PyErr_Occurred()) SWIG_fail;
48304 }
48305 resultobj = SWIG_Py_Void();
48306 return resultobj;
48307 fail:
48308 return NULL;
48309 }
48310
48311
48312 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48313 PyObject *resultobj = 0;
48314 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48315 int arg2 ;
48316 void *argp1 = 0 ;
48317 int res1 = 0 ;
48318 int val2 ;
48319 int ecode2 = 0 ;
48320 PyObject * obj0 = 0 ;
48321 PyObject * obj1 = 0 ;
48322 char * kwnames[] = {
48323 (char *) "self",(char *) "direction", NULL
48324 };
48325
48326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48328 if (!SWIG_IsOK(res1)) {
48329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48330 }
48331 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48332 ecode2 = SWIG_AsVal_int(obj1, &val2);
48333 if (!SWIG_IsOK(ecode2)) {
48334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48335 }
48336 arg2 = static_cast< int >(val2);
48337 {
48338 PyThreadState* __tstate = wxPyBeginAllowThreads();
48339 (arg1)->SetFlexibleDirection(arg2);
48340 wxPyEndAllowThreads(__tstate);
48341 if (PyErr_Occurred()) SWIG_fail;
48342 }
48343 resultobj = SWIG_Py_Void();
48344 return resultobj;
48345 fail:
48346 return NULL;
48347 }
48348
48349
48350 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48351 PyObject *resultobj = 0;
48352 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48353 int result;
48354 void *argp1 = 0 ;
48355 int res1 = 0 ;
48356 PyObject *swig_obj[1] ;
48357
48358 if (!args) SWIG_fail;
48359 swig_obj[0] = args;
48360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48361 if (!SWIG_IsOK(res1)) {
48362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48363 }
48364 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48365 {
48366 PyThreadState* __tstate = wxPyBeginAllowThreads();
48367 result = (int)(arg1)->GetFlexibleDirection();
48368 wxPyEndAllowThreads(__tstate);
48369 if (PyErr_Occurred()) SWIG_fail;
48370 }
48371 resultobj = SWIG_From_int(static_cast< int >(result));
48372 return resultobj;
48373 fail:
48374 return NULL;
48375 }
48376
48377
48378 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48379 PyObject *resultobj = 0;
48380 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48381 wxFlexSizerGrowMode arg2 ;
48382 void *argp1 = 0 ;
48383 int res1 = 0 ;
48384 int val2 ;
48385 int ecode2 = 0 ;
48386 PyObject * obj0 = 0 ;
48387 PyObject * obj1 = 0 ;
48388 char * kwnames[] = {
48389 (char *) "self",(char *) "mode", NULL
48390 };
48391
48392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48394 if (!SWIG_IsOK(res1)) {
48395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48396 }
48397 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48398 ecode2 = SWIG_AsVal_int(obj1, &val2);
48399 if (!SWIG_IsOK(ecode2)) {
48400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48401 }
48402 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48403 {
48404 PyThreadState* __tstate = wxPyBeginAllowThreads();
48405 (arg1)->SetNonFlexibleGrowMode(arg2);
48406 wxPyEndAllowThreads(__tstate);
48407 if (PyErr_Occurred()) SWIG_fail;
48408 }
48409 resultobj = SWIG_Py_Void();
48410 return resultobj;
48411 fail:
48412 return NULL;
48413 }
48414
48415
48416 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48417 PyObject *resultobj = 0;
48418 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48419 wxFlexSizerGrowMode result;
48420 void *argp1 = 0 ;
48421 int res1 = 0 ;
48422 PyObject *swig_obj[1] ;
48423
48424 if (!args) SWIG_fail;
48425 swig_obj[0] = args;
48426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48427 if (!SWIG_IsOK(res1)) {
48428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48429 }
48430 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48431 {
48432 PyThreadState* __tstate = wxPyBeginAllowThreads();
48433 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48434 wxPyEndAllowThreads(__tstate);
48435 if (PyErr_Occurred()) SWIG_fail;
48436 }
48437 resultobj = SWIG_From_int(static_cast< int >(result));
48438 return resultobj;
48439 fail:
48440 return NULL;
48441 }
48442
48443
48444 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48445 PyObject *resultobj = 0;
48446 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48447 wxArrayInt *result = 0 ;
48448 void *argp1 = 0 ;
48449 int res1 = 0 ;
48450 PyObject *swig_obj[1] ;
48451
48452 if (!args) SWIG_fail;
48453 swig_obj[0] = args;
48454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48455 if (!SWIG_IsOK(res1)) {
48456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48457 }
48458 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48459 {
48460 PyThreadState* __tstate = wxPyBeginAllowThreads();
48461 {
48462 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48463 result = (wxArrayInt *) &_result_ref;
48464 }
48465 wxPyEndAllowThreads(__tstate);
48466 if (PyErr_Occurred()) SWIG_fail;
48467 }
48468 {
48469 resultobj = PyList_New(0);
48470 size_t idx;
48471 for (idx = 0; idx < result->GetCount(); idx += 1) {
48472 PyObject* val = PyInt_FromLong( result->Item(idx) );
48473 PyList_Append(resultobj, val);
48474 Py_DECREF(val);
48475 }
48476 }
48477 return resultobj;
48478 fail:
48479 return NULL;
48480 }
48481
48482
48483 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48484 PyObject *resultobj = 0;
48485 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48486 wxArrayInt *result = 0 ;
48487 void *argp1 = 0 ;
48488 int res1 = 0 ;
48489 PyObject *swig_obj[1] ;
48490
48491 if (!args) SWIG_fail;
48492 swig_obj[0] = args;
48493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48494 if (!SWIG_IsOK(res1)) {
48495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48496 }
48497 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48498 {
48499 PyThreadState* __tstate = wxPyBeginAllowThreads();
48500 {
48501 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48502 result = (wxArrayInt *) &_result_ref;
48503 }
48504 wxPyEndAllowThreads(__tstate);
48505 if (PyErr_Occurred()) SWIG_fail;
48506 }
48507 {
48508 resultobj = PyList_New(0);
48509 size_t idx;
48510 for (idx = 0; idx < result->GetCount(); idx += 1) {
48511 PyObject* val = PyInt_FromLong( result->Item(idx) );
48512 PyList_Append(resultobj, val);
48513 Py_DECREF(val);
48514 }
48515 }
48516 return resultobj;
48517 fail:
48518 return NULL;
48519 }
48520
48521
48522 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48523 PyObject *obj;
48524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48525 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48526 return SWIG_Py_Void();
48527 }
48528
48529 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48530 return SWIG_Python_InitShadowInstance(args);
48531 }
48532
48533 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *resultobj = 0;
48535 wxStdDialogButtonSizer *result = 0 ;
48536
48537 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48538 {
48539 PyThreadState* __tstate = wxPyBeginAllowThreads();
48540 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48541 wxPyEndAllowThreads(__tstate);
48542 if (PyErr_Occurred()) SWIG_fail;
48543 }
48544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48545 return resultobj;
48546 fail:
48547 return NULL;
48548 }
48549
48550
48551 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48552 PyObject *resultobj = 0;
48553 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48554 wxButton *arg2 = (wxButton *) 0 ;
48555 void *argp1 = 0 ;
48556 int res1 = 0 ;
48557 void *argp2 = 0 ;
48558 int res2 = 0 ;
48559 PyObject * obj0 = 0 ;
48560 PyObject * obj1 = 0 ;
48561 char * kwnames[] = {
48562 (char *) "self",(char *) "button", NULL
48563 };
48564
48565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48567 if (!SWIG_IsOK(res1)) {
48568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48569 }
48570 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48572 if (!SWIG_IsOK(res2)) {
48573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48574 }
48575 arg2 = reinterpret_cast< wxButton * >(argp2);
48576 {
48577 PyThreadState* __tstate = wxPyBeginAllowThreads();
48578 (arg1)->AddButton(arg2);
48579 wxPyEndAllowThreads(__tstate);
48580 if (PyErr_Occurred()) SWIG_fail;
48581 }
48582 resultobj = SWIG_Py_Void();
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48590 PyObject *resultobj = 0;
48591 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48592 void *argp1 = 0 ;
48593 int res1 = 0 ;
48594 PyObject *swig_obj[1] ;
48595
48596 if (!args) SWIG_fail;
48597 swig_obj[0] = args;
48598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48599 if (!SWIG_IsOK(res1)) {
48600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48601 }
48602 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48603 {
48604 PyThreadState* __tstate = wxPyBeginAllowThreads();
48605 (arg1)->Realize();
48606 wxPyEndAllowThreads(__tstate);
48607 if (PyErr_Occurred()) SWIG_fail;
48608 }
48609 resultobj = SWIG_Py_Void();
48610 return resultobj;
48611 fail:
48612 return NULL;
48613 }
48614
48615
48616 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48617 PyObject *resultobj = 0;
48618 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48619 wxButton *arg2 = (wxButton *) 0 ;
48620 void *argp1 = 0 ;
48621 int res1 = 0 ;
48622 void *argp2 = 0 ;
48623 int res2 = 0 ;
48624 PyObject * obj0 = 0 ;
48625 PyObject * obj1 = 0 ;
48626 char * kwnames[] = {
48627 (char *) "self",(char *) "button", NULL
48628 };
48629
48630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48632 if (!SWIG_IsOK(res1)) {
48633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48634 }
48635 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48636 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48637 if (!SWIG_IsOK(res2)) {
48638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48639 }
48640 arg2 = reinterpret_cast< wxButton * >(argp2);
48641 {
48642 PyThreadState* __tstate = wxPyBeginAllowThreads();
48643 (arg1)->SetAffirmativeButton(arg2);
48644 wxPyEndAllowThreads(__tstate);
48645 if (PyErr_Occurred()) SWIG_fail;
48646 }
48647 resultobj = SWIG_Py_Void();
48648 return resultobj;
48649 fail:
48650 return NULL;
48651 }
48652
48653
48654 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48655 PyObject *resultobj = 0;
48656 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48657 wxButton *arg2 = (wxButton *) 0 ;
48658 void *argp1 = 0 ;
48659 int res1 = 0 ;
48660 void *argp2 = 0 ;
48661 int res2 = 0 ;
48662 PyObject * obj0 = 0 ;
48663 PyObject * obj1 = 0 ;
48664 char * kwnames[] = {
48665 (char *) "self",(char *) "button", NULL
48666 };
48667
48668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48672 }
48673 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48675 if (!SWIG_IsOK(res2)) {
48676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48677 }
48678 arg2 = reinterpret_cast< wxButton * >(argp2);
48679 {
48680 PyThreadState* __tstate = wxPyBeginAllowThreads();
48681 (arg1)->SetNegativeButton(arg2);
48682 wxPyEndAllowThreads(__tstate);
48683 if (PyErr_Occurred()) SWIG_fail;
48684 }
48685 resultobj = SWIG_Py_Void();
48686 return resultobj;
48687 fail:
48688 return NULL;
48689 }
48690
48691
48692 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48693 PyObject *resultobj = 0;
48694 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48695 wxButton *arg2 = (wxButton *) 0 ;
48696 void *argp1 = 0 ;
48697 int res1 = 0 ;
48698 void *argp2 = 0 ;
48699 int res2 = 0 ;
48700 PyObject * obj0 = 0 ;
48701 PyObject * obj1 = 0 ;
48702 char * kwnames[] = {
48703 (char *) "self",(char *) "button", NULL
48704 };
48705
48706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48708 if (!SWIG_IsOK(res1)) {
48709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48710 }
48711 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48713 if (!SWIG_IsOK(res2)) {
48714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48715 }
48716 arg2 = reinterpret_cast< wxButton * >(argp2);
48717 {
48718 PyThreadState* __tstate = wxPyBeginAllowThreads();
48719 (arg1)->SetCancelButton(arg2);
48720 wxPyEndAllowThreads(__tstate);
48721 if (PyErr_Occurred()) SWIG_fail;
48722 }
48723 resultobj = SWIG_Py_Void();
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48731 PyObject *resultobj = 0;
48732 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48733 wxButton *result = 0 ;
48734 void *argp1 = 0 ;
48735 int res1 = 0 ;
48736 PyObject *swig_obj[1] ;
48737
48738 if (!args) SWIG_fail;
48739 swig_obj[0] = args;
48740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48741 if (!SWIG_IsOK(res1)) {
48742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48743 }
48744 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48745 {
48746 PyThreadState* __tstate = wxPyBeginAllowThreads();
48747 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 {
48752 resultobj = wxPyMake_wxObject(result, (bool)0);
48753 }
48754 return resultobj;
48755 fail:
48756 return NULL;
48757 }
48758
48759
48760 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48761 PyObject *resultobj = 0;
48762 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48763 wxButton *result = 0 ;
48764 void *argp1 = 0 ;
48765 int res1 = 0 ;
48766 PyObject *swig_obj[1] ;
48767
48768 if (!args) SWIG_fail;
48769 swig_obj[0] = args;
48770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48773 }
48774 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 {
48782 resultobj = wxPyMake_wxObject(result, (bool)0);
48783 }
48784 return resultobj;
48785 fail:
48786 return NULL;
48787 }
48788
48789
48790 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48791 PyObject *resultobj = 0;
48792 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48793 wxButton *result = 0 ;
48794 void *argp1 = 0 ;
48795 int res1 = 0 ;
48796 PyObject *swig_obj[1] ;
48797
48798 if (!args) SWIG_fail;
48799 swig_obj[0] = args;
48800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48801 if (!SWIG_IsOK(res1)) {
48802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48803 }
48804 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48805 {
48806 PyThreadState* __tstate = wxPyBeginAllowThreads();
48807 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48808 wxPyEndAllowThreads(__tstate);
48809 if (PyErr_Occurred()) SWIG_fail;
48810 }
48811 {
48812 resultobj = wxPyMake_wxObject(result, (bool)0);
48813 }
48814 return resultobj;
48815 fail:
48816 return NULL;
48817 }
48818
48819
48820 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48821 PyObject *resultobj = 0;
48822 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48823 wxButton *result = 0 ;
48824 void *argp1 = 0 ;
48825 int res1 = 0 ;
48826 PyObject *swig_obj[1] ;
48827
48828 if (!args) SWIG_fail;
48829 swig_obj[0] = args;
48830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48831 if (!SWIG_IsOK(res1)) {
48832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48833 }
48834 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48835 {
48836 PyThreadState* __tstate = wxPyBeginAllowThreads();
48837 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48838 wxPyEndAllowThreads(__tstate);
48839 if (PyErr_Occurred()) SWIG_fail;
48840 }
48841 {
48842 resultobj = wxPyMake_wxObject(result, (bool)0);
48843 }
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 PyObject *resultobj = 0;
48852 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48853 wxButton *result = 0 ;
48854 void *argp1 = 0 ;
48855 int res1 = 0 ;
48856 PyObject *swig_obj[1] ;
48857
48858 if (!args) SWIG_fail;
48859 swig_obj[0] = args;
48860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48861 if (!SWIG_IsOK(res1)) {
48862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48863 }
48864 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48865 {
48866 PyThreadState* __tstate = wxPyBeginAllowThreads();
48867 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 {
48872 resultobj = wxPyMake_wxObject(result, (bool)0);
48873 }
48874 return resultobj;
48875 fail:
48876 return NULL;
48877 }
48878
48879
48880 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48881 PyObject *obj;
48882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48883 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48884 return SWIG_Py_Void();
48885 }
48886
48887 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48888 return SWIG_Python_InitShadowInstance(args);
48889 }
48890
48891 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48892 PyObject *resultobj = 0;
48893 int arg1 = (int) 0 ;
48894 int arg2 = (int) 0 ;
48895 wxGBPosition *result = 0 ;
48896 int val1 ;
48897 int ecode1 = 0 ;
48898 int val2 ;
48899 int ecode2 = 0 ;
48900 PyObject * obj0 = 0 ;
48901 PyObject * obj1 = 0 ;
48902 char * kwnames[] = {
48903 (char *) "row",(char *) "col", NULL
48904 };
48905
48906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48907 if (obj0) {
48908 ecode1 = SWIG_AsVal_int(obj0, &val1);
48909 if (!SWIG_IsOK(ecode1)) {
48910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48911 }
48912 arg1 = static_cast< int >(val1);
48913 }
48914 if (obj1) {
48915 ecode2 = SWIG_AsVal_int(obj1, &val2);
48916 if (!SWIG_IsOK(ecode2)) {
48917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48918 }
48919 arg2 = static_cast< int >(val2);
48920 }
48921 {
48922 PyThreadState* __tstate = wxPyBeginAllowThreads();
48923 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48924 wxPyEndAllowThreads(__tstate);
48925 if (PyErr_Occurred()) SWIG_fail;
48926 }
48927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48928 return resultobj;
48929 fail:
48930 return NULL;
48931 }
48932
48933
48934 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48935 PyObject *resultobj = 0;
48936 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48937 void *argp1 = 0 ;
48938 int res1 = 0 ;
48939 PyObject *swig_obj[1] ;
48940
48941 if (!args) SWIG_fail;
48942 swig_obj[0] = args;
48943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48944 if (!SWIG_IsOK(res1)) {
48945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48946 }
48947 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48948 {
48949 PyThreadState* __tstate = wxPyBeginAllowThreads();
48950 delete arg1;
48951
48952 wxPyEndAllowThreads(__tstate);
48953 if (PyErr_Occurred()) SWIG_fail;
48954 }
48955 resultobj = SWIG_Py_Void();
48956 return resultobj;
48957 fail:
48958 return NULL;
48959 }
48960
48961
48962 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48963 PyObject *resultobj = 0;
48964 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48965 int result;
48966 void *argp1 = 0 ;
48967 int res1 = 0 ;
48968 PyObject *swig_obj[1] ;
48969
48970 if (!args) SWIG_fail;
48971 swig_obj[0] = args;
48972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48973 if (!SWIG_IsOK(res1)) {
48974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48975 }
48976 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48977 {
48978 PyThreadState* __tstate = wxPyBeginAllowThreads();
48979 result = (int)((wxGBPosition const *)arg1)->GetRow();
48980 wxPyEndAllowThreads(__tstate);
48981 if (PyErr_Occurred()) SWIG_fail;
48982 }
48983 resultobj = SWIG_From_int(static_cast< int >(result));
48984 return resultobj;
48985 fail:
48986 return NULL;
48987 }
48988
48989
48990 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48991 PyObject *resultobj = 0;
48992 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48993 int result;
48994 void *argp1 = 0 ;
48995 int res1 = 0 ;
48996 PyObject *swig_obj[1] ;
48997
48998 if (!args) SWIG_fail;
48999 swig_obj[0] = args;
49000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49001 if (!SWIG_IsOK(res1)) {
49002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49003 }
49004 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49005 {
49006 PyThreadState* __tstate = wxPyBeginAllowThreads();
49007 result = (int)((wxGBPosition const *)arg1)->GetCol();
49008 wxPyEndAllowThreads(__tstate);
49009 if (PyErr_Occurred()) SWIG_fail;
49010 }
49011 resultobj = SWIG_From_int(static_cast< int >(result));
49012 return resultobj;
49013 fail:
49014 return NULL;
49015 }
49016
49017
49018 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49019 PyObject *resultobj = 0;
49020 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49021 int arg2 ;
49022 void *argp1 = 0 ;
49023 int res1 = 0 ;
49024 int val2 ;
49025 int ecode2 = 0 ;
49026 PyObject * obj0 = 0 ;
49027 PyObject * obj1 = 0 ;
49028 char * kwnames[] = {
49029 (char *) "self",(char *) "row", NULL
49030 };
49031
49032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49034 if (!SWIG_IsOK(res1)) {
49035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49036 }
49037 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49038 ecode2 = SWIG_AsVal_int(obj1, &val2);
49039 if (!SWIG_IsOK(ecode2)) {
49040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49041 }
49042 arg2 = static_cast< int >(val2);
49043 {
49044 PyThreadState* __tstate = wxPyBeginAllowThreads();
49045 (arg1)->SetRow(arg2);
49046 wxPyEndAllowThreads(__tstate);
49047 if (PyErr_Occurred()) SWIG_fail;
49048 }
49049 resultobj = SWIG_Py_Void();
49050 return resultobj;
49051 fail:
49052 return NULL;
49053 }
49054
49055
49056 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49057 PyObject *resultobj = 0;
49058 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49059 int arg2 ;
49060 void *argp1 = 0 ;
49061 int res1 = 0 ;
49062 int val2 ;
49063 int ecode2 = 0 ;
49064 PyObject * obj0 = 0 ;
49065 PyObject * obj1 = 0 ;
49066 char * kwnames[] = {
49067 (char *) "self",(char *) "col", NULL
49068 };
49069
49070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49072 if (!SWIG_IsOK(res1)) {
49073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49074 }
49075 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49076 ecode2 = SWIG_AsVal_int(obj1, &val2);
49077 if (!SWIG_IsOK(ecode2)) {
49078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49079 }
49080 arg2 = static_cast< int >(val2);
49081 {
49082 PyThreadState* __tstate = wxPyBeginAllowThreads();
49083 (arg1)->SetCol(arg2);
49084 wxPyEndAllowThreads(__tstate);
49085 if (PyErr_Occurred()) SWIG_fail;
49086 }
49087 resultobj = SWIG_Py_Void();
49088 return resultobj;
49089 fail:
49090 return NULL;
49091 }
49092
49093
49094 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49095 PyObject *resultobj = 0;
49096 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49097 PyObject *arg2 = (PyObject *) 0 ;
49098 bool result;
49099 void *argp1 = 0 ;
49100 int res1 = 0 ;
49101 PyObject * obj0 = 0 ;
49102 PyObject * obj1 = 0 ;
49103 char * kwnames[] = {
49104 (char *) "self",(char *) "other", NULL
49105 };
49106
49107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49109 if (!SWIG_IsOK(res1)) {
49110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49111 }
49112 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49113 arg2 = obj1;
49114 {
49115 result = (bool)wxGBPosition___eq__(arg1,arg2);
49116 if (PyErr_Occurred()) SWIG_fail;
49117 }
49118 {
49119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49120 }
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49128 PyObject *resultobj = 0;
49129 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49130 PyObject *arg2 = (PyObject *) 0 ;
49131 bool result;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 PyObject * obj0 = 0 ;
49135 PyObject * obj1 = 0 ;
49136 char * kwnames[] = {
49137 (char *) "self",(char *) "other", NULL
49138 };
49139
49140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49142 if (!SWIG_IsOK(res1)) {
49143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49144 }
49145 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49146 arg2 = obj1;
49147 {
49148 result = (bool)wxGBPosition___ne__(arg1,arg2);
49149 if (PyErr_Occurred()) SWIG_fail;
49150 }
49151 {
49152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49153 }
49154 return resultobj;
49155 fail:
49156 return NULL;
49157 }
49158
49159
49160 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49161 PyObject *resultobj = 0;
49162 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49163 int arg2 = (int) 0 ;
49164 int arg3 = (int) 0 ;
49165 void *argp1 = 0 ;
49166 int res1 = 0 ;
49167 int val2 ;
49168 int ecode2 = 0 ;
49169 int val3 ;
49170 int ecode3 = 0 ;
49171 PyObject * obj0 = 0 ;
49172 PyObject * obj1 = 0 ;
49173 PyObject * obj2 = 0 ;
49174 char * kwnames[] = {
49175 (char *) "self",(char *) "row",(char *) "col", NULL
49176 };
49177
49178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49180 if (!SWIG_IsOK(res1)) {
49181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49182 }
49183 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49184 if (obj1) {
49185 ecode2 = SWIG_AsVal_int(obj1, &val2);
49186 if (!SWIG_IsOK(ecode2)) {
49187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49188 }
49189 arg2 = static_cast< int >(val2);
49190 }
49191 if (obj2) {
49192 ecode3 = SWIG_AsVal_int(obj2, &val3);
49193 if (!SWIG_IsOK(ecode3)) {
49194 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49195 }
49196 arg3 = static_cast< int >(val3);
49197 }
49198 {
49199 PyThreadState* __tstate = wxPyBeginAllowThreads();
49200 wxGBPosition_Set(arg1,arg2,arg3);
49201 wxPyEndAllowThreads(__tstate);
49202 if (PyErr_Occurred()) SWIG_fail;
49203 }
49204 resultobj = SWIG_Py_Void();
49205 return resultobj;
49206 fail:
49207 return NULL;
49208 }
49209
49210
49211 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49212 PyObject *resultobj = 0;
49213 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49214 PyObject *result = 0 ;
49215 void *argp1 = 0 ;
49216 int res1 = 0 ;
49217 PyObject *swig_obj[1] ;
49218
49219 if (!args) SWIG_fail;
49220 swig_obj[0] = args;
49221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49222 if (!SWIG_IsOK(res1)) {
49223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49224 }
49225 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49226 {
49227 PyThreadState* __tstate = wxPyBeginAllowThreads();
49228 result = (PyObject *)wxGBPosition_Get(arg1);
49229 wxPyEndAllowThreads(__tstate);
49230 if (PyErr_Occurred()) SWIG_fail;
49231 }
49232 resultobj = result;
49233 return resultobj;
49234 fail:
49235 return NULL;
49236 }
49237
49238
49239 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49240 PyObject *obj;
49241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49242 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49243 return SWIG_Py_Void();
49244 }
49245
49246 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49247 return SWIG_Python_InitShadowInstance(args);
49248 }
49249
49250 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49251 PyObject *resultobj = 0;
49252 int arg1 = (int) 1 ;
49253 int arg2 = (int) 1 ;
49254 wxGBSpan *result = 0 ;
49255 int val1 ;
49256 int ecode1 = 0 ;
49257 int val2 ;
49258 int ecode2 = 0 ;
49259 PyObject * obj0 = 0 ;
49260 PyObject * obj1 = 0 ;
49261 char * kwnames[] = {
49262 (char *) "rowspan",(char *) "colspan", NULL
49263 };
49264
49265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49266 if (obj0) {
49267 ecode1 = SWIG_AsVal_int(obj0, &val1);
49268 if (!SWIG_IsOK(ecode1)) {
49269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49270 }
49271 arg1 = static_cast< int >(val1);
49272 }
49273 if (obj1) {
49274 ecode2 = SWIG_AsVal_int(obj1, &val2);
49275 if (!SWIG_IsOK(ecode2)) {
49276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49277 }
49278 arg2 = static_cast< int >(val2);
49279 }
49280 {
49281 PyThreadState* __tstate = wxPyBeginAllowThreads();
49282 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49283 wxPyEndAllowThreads(__tstate);
49284 if (PyErr_Occurred()) SWIG_fail;
49285 }
49286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49287 return resultobj;
49288 fail:
49289 return NULL;
49290 }
49291
49292
49293 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49294 PyObject *resultobj = 0;
49295 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49296 void *argp1 = 0 ;
49297 int res1 = 0 ;
49298 PyObject *swig_obj[1] ;
49299
49300 if (!args) SWIG_fail;
49301 swig_obj[0] = args;
49302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49303 if (!SWIG_IsOK(res1)) {
49304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49305 }
49306 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49307 {
49308 PyThreadState* __tstate = wxPyBeginAllowThreads();
49309 delete arg1;
49310
49311 wxPyEndAllowThreads(__tstate);
49312 if (PyErr_Occurred()) SWIG_fail;
49313 }
49314 resultobj = SWIG_Py_Void();
49315 return resultobj;
49316 fail:
49317 return NULL;
49318 }
49319
49320
49321 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49322 PyObject *resultobj = 0;
49323 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49324 int result;
49325 void *argp1 = 0 ;
49326 int res1 = 0 ;
49327 PyObject *swig_obj[1] ;
49328
49329 if (!args) SWIG_fail;
49330 swig_obj[0] = args;
49331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49332 if (!SWIG_IsOK(res1)) {
49333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49334 }
49335 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49336 {
49337 PyThreadState* __tstate = wxPyBeginAllowThreads();
49338 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49339 wxPyEndAllowThreads(__tstate);
49340 if (PyErr_Occurred()) SWIG_fail;
49341 }
49342 resultobj = SWIG_From_int(static_cast< int >(result));
49343 return resultobj;
49344 fail:
49345 return NULL;
49346 }
49347
49348
49349 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49350 PyObject *resultobj = 0;
49351 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49352 int result;
49353 void *argp1 = 0 ;
49354 int res1 = 0 ;
49355 PyObject *swig_obj[1] ;
49356
49357 if (!args) SWIG_fail;
49358 swig_obj[0] = args;
49359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49360 if (!SWIG_IsOK(res1)) {
49361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49362 }
49363 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49364 {
49365 PyThreadState* __tstate = wxPyBeginAllowThreads();
49366 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49367 wxPyEndAllowThreads(__tstate);
49368 if (PyErr_Occurred()) SWIG_fail;
49369 }
49370 resultobj = SWIG_From_int(static_cast< int >(result));
49371 return resultobj;
49372 fail:
49373 return NULL;
49374 }
49375
49376
49377 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49378 PyObject *resultobj = 0;
49379 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49380 int arg2 ;
49381 void *argp1 = 0 ;
49382 int res1 = 0 ;
49383 int val2 ;
49384 int ecode2 = 0 ;
49385 PyObject * obj0 = 0 ;
49386 PyObject * obj1 = 0 ;
49387 char * kwnames[] = {
49388 (char *) "self",(char *) "rowspan", NULL
49389 };
49390
49391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49393 if (!SWIG_IsOK(res1)) {
49394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49395 }
49396 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49397 ecode2 = SWIG_AsVal_int(obj1, &val2);
49398 if (!SWIG_IsOK(ecode2)) {
49399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49400 }
49401 arg2 = static_cast< int >(val2);
49402 {
49403 PyThreadState* __tstate = wxPyBeginAllowThreads();
49404 (arg1)->SetRowspan(arg2);
49405 wxPyEndAllowThreads(__tstate);
49406 if (PyErr_Occurred()) SWIG_fail;
49407 }
49408 resultobj = SWIG_Py_Void();
49409 return resultobj;
49410 fail:
49411 return NULL;
49412 }
49413
49414
49415 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49416 PyObject *resultobj = 0;
49417 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49418 int arg2 ;
49419 void *argp1 = 0 ;
49420 int res1 = 0 ;
49421 int val2 ;
49422 int ecode2 = 0 ;
49423 PyObject * obj0 = 0 ;
49424 PyObject * obj1 = 0 ;
49425 char * kwnames[] = {
49426 (char *) "self",(char *) "colspan", NULL
49427 };
49428
49429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49431 if (!SWIG_IsOK(res1)) {
49432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49433 }
49434 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49435 ecode2 = SWIG_AsVal_int(obj1, &val2);
49436 if (!SWIG_IsOK(ecode2)) {
49437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49438 }
49439 arg2 = static_cast< int >(val2);
49440 {
49441 PyThreadState* __tstate = wxPyBeginAllowThreads();
49442 (arg1)->SetColspan(arg2);
49443 wxPyEndAllowThreads(__tstate);
49444 if (PyErr_Occurred()) SWIG_fail;
49445 }
49446 resultobj = SWIG_Py_Void();
49447 return resultobj;
49448 fail:
49449 return NULL;
49450 }
49451
49452
49453 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49454 PyObject *resultobj = 0;
49455 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49456 PyObject *arg2 = (PyObject *) 0 ;
49457 bool result;
49458 void *argp1 = 0 ;
49459 int res1 = 0 ;
49460 PyObject * obj0 = 0 ;
49461 PyObject * obj1 = 0 ;
49462 char * kwnames[] = {
49463 (char *) "self",(char *) "other", NULL
49464 };
49465
49466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49468 if (!SWIG_IsOK(res1)) {
49469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49470 }
49471 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49472 arg2 = obj1;
49473 {
49474 result = (bool)wxGBSpan___eq__(arg1,arg2);
49475 if (PyErr_Occurred()) SWIG_fail;
49476 }
49477 {
49478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49479 }
49480 return resultobj;
49481 fail:
49482 return NULL;
49483 }
49484
49485
49486 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49487 PyObject *resultobj = 0;
49488 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49489 PyObject *arg2 = (PyObject *) 0 ;
49490 bool result;
49491 void *argp1 = 0 ;
49492 int res1 = 0 ;
49493 PyObject * obj0 = 0 ;
49494 PyObject * obj1 = 0 ;
49495 char * kwnames[] = {
49496 (char *) "self",(char *) "other", NULL
49497 };
49498
49499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49501 if (!SWIG_IsOK(res1)) {
49502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49503 }
49504 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49505 arg2 = obj1;
49506 {
49507 result = (bool)wxGBSpan___ne__(arg1,arg2);
49508 if (PyErr_Occurred()) SWIG_fail;
49509 }
49510 {
49511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49512 }
49513 return resultobj;
49514 fail:
49515 return NULL;
49516 }
49517
49518
49519 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49520 PyObject *resultobj = 0;
49521 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49522 int arg2 = (int) 1 ;
49523 int arg3 = (int) 1 ;
49524 void *argp1 = 0 ;
49525 int res1 = 0 ;
49526 int val2 ;
49527 int ecode2 = 0 ;
49528 int val3 ;
49529 int ecode3 = 0 ;
49530 PyObject * obj0 = 0 ;
49531 PyObject * obj1 = 0 ;
49532 PyObject * obj2 = 0 ;
49533 char * kwnames[] = {
49534 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49535 };
49536
49537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49539 if (!SWIG_IsOK(res1)) {
49540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49541 }
49542 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49543 if (obj1) {
49544 ecode2 = SWIG_AsVal_int(obj1, &val2);
49545 if (!SWIG_IsOK(ecode2)) {
49546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49547 }
49548 arg2 = static_cast< int >(val2);
49549 }
49550 if (obj2) {
49551 ecode3 = SWIG_AsVal_int(obj2, &val3);
49552 if (!SWIG_IsOK(ecode3)) {
49553 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49554 }
49555 arg3 = static_cast< int >(val3);
49556 }
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 wxGBSpan_Set(arg1,arg2,arg3);
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_Py_Void();
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49571 PyObject *resultobj = 0;
49572 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49573 PyObject *result = 0 ;
49574 void *argp1 = 0 ;
49575 int res1 = 0 ;
49576 PyObject *swig_obj[1] ;
49577
49578 if (!args) SWIG_fail;
49579 swig_obj[0] = args;
49580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49581 if (!SWIG_IsOK(res1)) {
49582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49583 }
49584 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49585 {
49586 PyThreadState* __tstate = wxPyBeginAllowThreads();
49587 result = (PyObject *)wxGBSpan_Get(arg1);
49588 wxPyEndAllowThreads(__tstate);
49589 if (PyErr_Occurred()) SWIG_fail;
49590 }
49591 resultobj = result;
49592 return resultobj;
49593 fail:
49594 return NULL;
49595 }
49596
49597
49598 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49599 PyObject *obj;
49600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49601 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49602 return SWIG_Py_Void();
49603 }
49604
49605 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49606 return SWIG_Python_InitShadowInstance(args);
49607 }
49608
49609 SWIGINTERN int DefaultSpan_set(PyObject *) {
49610 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49611 return 1;
49612 }
49613
49614
49615 SWIGINTERN PyObject *DefaultSpan_get(void) {
49616 PyObject *pyobj = 0;
49617
49618 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49619 return pyobj;
49620 }
49621
49622
49623 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49624 PyObject *resultobj = 0;
49625 wxGBSizerItem *result = 0 ;
49626
49627 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49628 {
49629 PyThreadState* __tstate = wxPyBeginAllowThreads();
49630 result = (wxGBSizerItem *)new wxGBSizerItem();
49631 wxPyEndAllowThreads(__tstate);
49632 if (PyErr_Occurred()) SWIG_fail;
49633 }
49634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49635 return resultobj;
49636 fail:
49637 return NULL;
49638 }
49639
49640
49641 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49642 PyObject *resultobj = 0;
49643 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 PyObject *swig_obj[1] ;
49647
49648 if (!args) SWIG_fail;
49649 swig_obj[0] = args;
49650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49653 }
49654 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 delete arg1;
49658
49659 wxPyEndAllowThreads(__tstate);
49660 if (PyErr_Occurred()) SWIG_fail;
49661 }
49662 resultobj = SWIG_Py_Void();
49663 return resultobj;
49664 fail:
49665 return NULL;
49666 }
49667
49668
49669 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49670 PyObject *resultobj = 0;
49671 wxWindow *arg1 = (wxWindow *) 0 ;
49672 wxGBPosition *arg2 = 0 ;
49673 wxGBSpan *arg3 = 0 ;
49674 int arg4 ;
49675 int arg5 ;
49676 PyObject *arg6 = (PyObject *) NULL ;
49677 wxGBSizerItem *result = 0 ;
49678 void *argp1 = 0 ;
49679 int res1 = 0 ;
49680 wxGBPosition temp2 ;
49681 wxGBSpan temp3 ;
49682 int val4 ;
49683 int ecode4 = 0 ;
49684 int val5 ;
49685 int ecode5 = 0 ;
49686 PyObject * obj0 = 0 ;
49687 PyObject * obj1 = 0 ;
49688 PyObject * obj2 = 0 ;
49689 PyObject * obj3 = 0 ;
49690 PyObject * obj4 = 0 ;
49691 PyObject * obj5 = 0 ;
49692 char * kwnames[] = {
49693 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49694 };
49695
49696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49698 if (!SWIG_IsOK(res1)) {
49699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49700 }
49701 arg1 = reinterpret_cast< wxWindow * >(argp1);
49702 {
49703 arg2 = &temp2;
49704 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49705 }
49706 {
49707 arg3 = &temp3;
49708 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49709 }
49710 ecode4 = SWIG_AsVal_int(obj3, &val4);
49711 if (!SWIG_IsOK(ecode4)) {
49712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49713 }
49714 arg4 = static_cast< int >(val4);
49715 ecode5 = SWIG_AsVal_int(obj4, &val5);
49716 if (!SWIG_IsOK(ecode5)) {
49717 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49718 }
49719 arg5 = static_cast< int >(val5);
49720 if (obj5) {
49721 arg6 = obj5;
49722 }
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49737 PyObject *resultobj = 0;
49738 wxSizer *arg1 = (wxSizer *) 0 ;
49739 wxGBPosition *arg2 = 0 ;
49740 wxGBSpan *arg3 = 0 ;
49741 int arg4 ;
49742 int arg5 ;
49743 PyObject *arg6 = (PyObject *) NULL ;
49744 wxGBSizerItem *result = 0 ;
49745 int res1 = 0 ;
49746 wxGBPosition temp2 ;
49747 wxGBSpan temp3 ;
49748 int val4 ;
49749 int ecode4 = 0 ;
49750 int val5 ;
49751 int ecode5 = 0 ;
49752 PyObject * obj0 = 0 ;
49753 PyObject * obj1 = 0 ;
49754 PyObject * obj2 = 0 ;
49755 PyObject * obj3 = 0 ;
49756 PyObject * obj4 = 0 ;
49757 PyObject * obj5 = 0 ;
49758 char * kwnames[] = {
49759 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49760 };
49761
49762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49763 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49764 if (!SWIG_IsOK(res1)) {
49765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49766 }
49767 {
49768 arg2 = &temp2;
49769 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49770 }
49771 {
49772 arg3 = &temp3;
49773 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49774 }
49775 ecode4 = SWIG_AsVal_int(obj3, &val4);
49776 if (!SWIG_IsOK(ecode4)) {
49777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49778 }
49779 arg4 = static_cast< int >(val4);
49780 ecode5 = SWIG_AsVal_int(obj4, &val5);
49781 if (!SWIG_IsOK(ecode5)) {
49782 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49783 }
49784 arg5 = static_cast< int >(val5);
49785 if (obj5) {
49786 arg6 = obj5;
49787 }
49788 {
49789 PyThreadState* __tstate = wxPyBeginAllowThreads();
49790 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49791 wxPyEndAllowThreads(__tstate);
49792 if (PyErr_Occurred()) SWIG_fail;
49793 }
49794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49795 return resultobj;
49796 fail:
49797 return NULL;
49798 }
49799
49800
49801 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49802 PyObject *resultobj = 0;
49803 int arg1 ;
49804 int arg2 ;
49805 wxGBPosition *arg3 = 0 ;
49806 wxGBSpan *arg4 = 0 ;
49807 int arg5 ;
49808 int arg6 ;
49809 PyObject *arg7 = (PyObject *) NULL ;
49810 wxGBSizerItem *result = 0 ;
49811 int val1 ;
49812 int ecode1 = 0 ;
49813 int val2 ;
49814 int ecode2 = 0 ;
49815 wxGBPosition temp3 ;
49816 wxGBSpan temp4 ;
49817 int val5 ;
49818 int ecode5 = 0 ;
49819 int val6 ;
49820 int ecode6 = 0 ;
49821 PyObject * obj0 = 0 ;
49822 PyObject * obj1 = 0 ;
49823 PyObject * obj2 = 0 ;
49824 PyObject * obj3 = 0 ;
49825 PyObject * obj4 = 0 ;
49826 PyObject * obj5 = 0 ;
49827 PyObject * obj6 = 0 ;
49828 char * kwnames[] = {
49829 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49830 };
49831
49832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49833 ecode1 = SWIG_AsVal_int(obj0, &val1);
49834 if (!SWIG_IsOK(ecode1)) {
49835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49836 }
49837 arg1 = static_cast< int >(val1);
49838 ecode2 = SWIG_AsVal_int(obj1, &val2);
49839 if (!SWIG_IsOK(ecode2)) {
49840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49841 }
49842 arg2 = static_cast< int >(val2);
49843 {
49844 arg3 = &temp3;
49845 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49846 }
49847 {
49848 arg4 = &temp4;
49849 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49850 }
49851 ecode5 = SWIG_AsVal_int(obj4, &val5);
49852 if (!SWIG_IsOK(ecode5)) {
49853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49854 }
49855 arg5 = static_cast< int >(val5);
49856 ecode6 = SWIG_AsVal_int(obj5, &val6);
49857 if (!SWIG_IsOK(ecode6)) {
49858 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49859 }
49860 arg6 = static_cast< int >(val6);
49861 if (obj6) {
49862 arg7 = obj6;
49863 }
49864 {
49865 PyThreadState* __tstate = wxPyBeginAllowThreads();
49866 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49867 wxPyEndAllowThreads(__tstate);
49868 if (PyErr_Occurred()) SWIG_fail;
49869 }
49870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49878 PyObject *resultobj = 0;
49879 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49880 wxGBPosition result;
49881 void *argp1 = 0 ;
49882 int res1 = 0 ;
49883 PyObject *swig_obj[1] ;
49884
49885 if (!args) SWIG_fail;
49886 swig_obj[0] = args;
49887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49890 }
49891 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49892 {
49893 PyThreadState* __tstate = wxPyBeginAllowThreads();
49894 result = ((wxGBSizerItem const *)arg1)->GetPos();
49895 wxPyEndAllowThreads(__tstate);
49896 if (PyErr_Occurred()) SWIG_fail;
49897 }
49898 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49899 return resultobj;
49900 fail:
49901 return NULL;
49902 }
49903
49904
49905 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49906 PyObject *resultobj = 0;
49907 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49908 wxGBSpan result;
49909 void *argp1 = 0 ;
49910 int res1 = 0 ;
49911 PyObject *swig_obj[1] ;
49912
49913 if (!args) SWIG_fail;
49914 swig_obj[0] = args;
49915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49916 if (!SWIG_IsOK(res1)) {
49917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49918 }
49919 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49920 {
49921 PyThreadState* __tstate = wxPyBeginAllowThreads();
49922 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49923 wxPyEndAllowThreads(__tstate);
49924 if (PyErr_Occurred()) SWIG_fail;
49925 }
49926 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49927 return resultobj;
49928 fail:
49929 return NULL;
49930 }
49931
49932
49933 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49934 PyObject *resultobj = 0;
49935 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49936 wxGBPosition *arg2 = 0 ;
49937 bool result;
49938 void *argp1 = 0 ;
49939 int res1 = 0 ;
49940 wxGBPosition temp2 ;
49941 PyObject * obj0 = 0 ;
49942 PyObject * obj1 = 0 ;
49943 char * kwnames[] = {
49944 (char *) "self",(char *) "pos", NULL
49945 };
49946
49947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49949 if (!SWIG_IsOK(res1)) {
49950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49951 }
49952 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49953 {
49954 arg2 = &temp2;
49955 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49956 }
49957 {
49958 PyThreadState* __tstate = wxPyBeginAllowThreads();
49959 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49960 wxPyEndAllowThreads(__tstate);
49961 if (PyErr_Occurred()) SWIG_fail;
49962 }
49963 {
49964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49965 }
49966 return resultobj;
49967 fail:
49968 return NULL;
49969 }
49970
49971
49972 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49973 PyObject *resultobj = 0;
49974 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49975 wxGBSpan *arg2 = 0 ;
49976 bool result;
49977 void *argp1 = 0 ;
49978 int res1 = 0 ;
49979 wxGBSpan temp2 ;
49980 PyObject * obj0 = 0 ;
49981 PyObject * obj1 = 0 ;
49982 char * kwnames[] = {
49983 (char *) "self",(char *) "span", NULL
49984 };
49985
49986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49988 if (!SWIG_IsOK(res1)) {
49989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49990 }
49991 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49992 {
49993 arg2 = &temp2;
49994 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49995 }
49996 {
49997 PyThreadState* __tstate = wxPyBeginAllowThreads();
49998 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49999 wxPyEndAllowThreads(__tstate);
50000 if (PyErr_Occurred()) SWIG_fail;
50001 }
50002 {
50003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50004 }
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50012 PyObject *resultobj = 0;
50013 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50014 wxGBSizerItem *arg2 = 0 ;
50015 bool result;
50016 void *argp1 = 0 ;
50017 int res1 = 0 ;
50018 void *argp2 = 0 ;
50019 int res2 = 0 ;
50020 PyObject * obj0 = 0 ;
50021 PyObject * obj1 = 0 ;
50022 char * kwnames[] = {
50023 (char *) "self",(char *) "other", NULL
50024 };
50025
50026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50028 if (!SWIG_IsOK(res1)) {
50029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50030 }
50031 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50032 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50033 if (!SWIG_IsOK(res2)) {
50034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50035 }
50036 if (!argp2) {
50037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50038 }
50039 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50040 {
50041 PyThreadState* __tstate = wxPyBeginAllowThreads();
50042 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50043 wxPyEndAllowThreads(__tstate);
50044 if (PyErr_Occurred()) SWIG_fail;
50045 }
50046 {
50047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50048 }
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50056 PyObject *resultobj = 0;
50057 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50058 wxGBPosition *arg2 = 0 ;
50059 wxGBSpan *arg3 = 0 ;
50060 bool result;
50061 void *argp1 = 0 ;
50062 int res1 = 0 ;
50063 wxGBPosition temp2 ;
50064 wxGBSpan temp3 ;
50065 PyObject * obj0 = 0 ;
50066 PyObject * obj1 = 0 ;
50067 PyObject * obj2 = 0 ;
50068 char * kwnames[] = {
50069 (char *) "self",(char *) "pos",(char *) "span", NULL
50070 };
50071
50072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50074 if (!SWIG_IsOK(res1)) {
50075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50076 }
50077 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50078 {
50079 arg2 = &temp2;
50080 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50081 }
50082 {
50083 arg3 = &temp3;
50084 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50085 }
50086 {
50087 PyThreadState* __tstate = wxPyBeginAllowThreads();
50088 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50089 wxPyEndAllowThreads(__tstate);
50090 if (PyErr_Occurred()) SWIG_fail;
50091 }
50092 {
50093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50094 }
50095 return resultobj;
50096 fail:
50097 return NULL;
50098 }
50099
50100
50101 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50102 PyObject *resultobj = 0;
50103 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50104 wxGBPosition result;
50105 void *argp1 = 0 ;
50106 int res1 = 0 ;
50107 PyObject *swig_obj[1] ;
50108
50109 if (!args) SWIG_fail;
50110 swig_obj[0] = args;
50111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50112 if (!SWIG_IsOK(res1)) {
50113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50114 }
50115 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50116 {
50117 PyThreadState* __tstate = wxPyBeginAllowThreads();
50118 result = wxGBSizerItem_GetEndPos(arg1);
50119 wxPyEndAllowThreads(__tstate);
50120 if (PyErr_Occurred()) SWIG_fail;
50121 }
50122 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50123 return resultobj;
50124 fail:
50125 return NULL;
50126 }
50127
50128
50129 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50130 PyObject *resultobj = 0;
50131 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50132 wxGridBagSizer *result = 0 ;
50133 void *argp1 = 0 ;
50134 int res1 = 0 ;
50135 PyObject *swig_obj[1] ;
50136
50137 if (!args) SWIG_fail;
50138 swig_obj[0] = args;
50139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50140 if (!SWIG_IsOK(res1)) {
50141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50142 }
50143 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50144 {
50145 PyThreadState* __tstate = wxPyBeginAllowThreads();
50146 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50147 wxPyEndAllowThreads(__tstate);
50148 if (PyErr_Occurred()) SWIG_fail;
50149 }
50150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50151 return resultobj;
50152 fail:
50153 return NULL;
50154 }
50155
50156
50157 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50158 PyObject *resultobj = 0;
50159 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50160 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50161 void *argp1 = 0 ;
50162 int res1 = 0 ;
50163 void *argp2 = 0 ;
50164 int res2 = 0 ;
50165 PyObject * obj0 = 0 ;
50166 PyObject * obj1 = 0 ;
50167 char * kwnames[] = {
50168 (char *) "self",(char *) "sizer", NULL
50169 };
50170
50171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50173 if (!SWIG_IsOK(res1)) {
50174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50175 }
50176 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50178 if (!SWIG_IsOK(res2)) {
50179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50180 }
50181 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50182 {
50183 PyThreadState* __tstate = wxPyBeginAllowThreads();
50184 (arg1)->SetGBSizer(arg2);
50185 wxPyEndAllowThreads(__tstate);
50186 if (PyErr_Occurred()) SWIG_fail;
50187 }
50188 resultobj = SWIG_Py_Void();
50189 return resultobj;
50190 fail:
50191 return NULL;
50192 }
50193
50194
50195 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50196 PyObject *obj;
50197 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50198 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50199 return SWIG_Py_Void();
50200 }
50201
50202 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50203 return SWIG_Python_InitShadowInstance(args);
50204 }
50205
50206 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50207 PyObject *resultobj = 0;
50208 int arg1 = (int) 0 ;
50209 int arg2 = (int) 0 ;
50210 wxGridBagSizer *result = 0 ;
50211 int val1 ;
50212 int ecode1 = 0 ;
50213 int val2 ;
50214 int ecode2 = 0 ;
50215 PyObject * obj0 = 0 ;
50216 PyObject * obj1 = 0 ;
50217 char * kwnames[] = {
50218 (char *) "vgap",(char *) "hgap", NULL
50219 };
50220
50221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50222 if (obj0) {
50223 ecode1 = SWIG_AsVal_int(obj0, &val1);
50224 if (!SWIG_IsOK(ecode1)) {
50225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50226 }
50227 arg1 = static_cast< int >(val1);
50228 }
50229 if (obj1) {
50230 ecode2 = SWIG_AsVal_int(obj1, &val2);
50231 if (!SWIG_IsOK(ecode2)) {
50232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50233 }
50234 arg2 = static_cast< int >(val2);
50235 }
50236 {
50237 PyThreadState* __tstate = wxPyBeginAllowThreads();
50238 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50239 wxPyEndAllowThreads(__tstate);
50240 if (PyErr_Occurred()) SWIG_fail;
50241 }
50242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50243 return resultobj;
50244 fail:
50245 return NULL;
50246 }
50247
50248
50249 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50250 PyObject *resultobj = 0;
50251 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50252 PyObject *arg2 = (PyObject *) 0 ;
50253 wxGBPosition *arg3 = 0 ;
50254 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50255 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50256 int arg5 = (int) 0 ;
50257 int arg6 = (int) 0 ;
50258 PyObject *arg7 = (PyObject *) NULL ;
50259 wxGBSizerItem *result = 0 ;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 wxGBPosition temp3 ;
50263 wxGBSpan temp4 ;
50264 int val5 ;
50265 int ecode5 = 0 ;
50266 int val6 ;
50267 int ecode6 = 0 ;
50268 PyObject * obj0 = 0 ;
50269 PyObject * obj1 = 0 ;
50270 PyObject * obj2 = 0 ;
50271 PyObject * obj3 = 0 ;
50272 PyObject * obj4 = 0 ;
50273 PyObject * obj5 = 0 ;
50274 PyObject * obj6 = 0 ;
50275 char * kwnames[] = {
50276 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50277 };
50278
50279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50281 if (!SWIG_IsOK(res1)) {
50282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50283 }
50284 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50285 arg2 = obj1;
50286 {
50287 arg3 = &temp3;
50288 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50289 }
50290 if (obj3) {
50291 {
50292 arg4 = &temp4;
50293 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50294 }
50295 }
50296 if (obj4) {
50297 ecode5 = SWIG_AsVal_int(obj4, &val5);
50298 if (!SWIG_IsOK(ecode5)) {
50299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50300 }
50301 arg5 = static_cast< int >(val5);
50302 }
50303 if (obj5) {
50304 ecode6 = SWIG_AsVal_int(obj5, &val6);
50305 if (!SWIG_IsOK(ecode6)) {
50306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50307 }
50308 arg6 = static_cast< int >(val6);
50309 }
50310 if (obj6) {
50311 arg7 = obj6;
50312 }
50313 {
50314 PyThreadState* __tstate = wxPyBeginAllowThreads();
50315 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50316 wxPyEndAllowThreads(__tstate);
50317 if (PyErr_Occurred()) SWIG_fail;
50318 }
50319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50320 return resultobj;
50321 fail:
50322 return NULL;
50323 }
50324
50325
50326 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50327 PyObject *resultobj = 0;
50328 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50329 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50330 wxGBSizerItem *result = 0 ;
50331 void *argp1 = 0 ;
50332 int res1 = 0 ;
50333 int res2 = 0 ;
50334 PyObject * obj0 = 0 ;
50335 PyObject * obj1 = 0 ;
50336 char * kwnames[] = {
50337 (char *) "self",(char *) "item", NULL
50338 };
50339
50340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50342 if (!SWIG_IsOK(res1)) {
50343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50344 }
50345 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50346 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50347 if (!SWIG_IsOK(res2)) {
50348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50349 }
50350 {
50351 PyThreadState* __tstate = wxPyBeginAllowThreads();
50352 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50353 wxPyEndAllowThreads(__tstate);
50354 if (PyErr_Occurred()) SWIG_fail;
50355 }
50356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50357 return resultobj;
50358 fail:
50359 return NULL;
50360 }
50361
50362
50363 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50364 PyObject *resultobj = 0;
50365 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50366 int arg2 ;
50367 int arg3 ;
50368 wxSize result;
50369 void *argp1 = 0 ;
50370 int res1 = 0 ;
50371 int val2 ;
50372 int ecode2 = 0 ;
50373 int val3 ;
50374 int ecode3 = 0 ;
50375 PyObject * obj0 = 0 ;
50376 PyObject * obj1 = 0 ;
50377 PyObject * obj2 = 0 ;
50378 char * kwnames[] = {
50379 (char *) "self",(char *) "row",(char *) "col", NULL
50380 };
50381
50382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50384 if (!SWIG_IsOK(res1)) {
50385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50386 }
50387 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50388 ecode2 = SWIG_AsVal_int(obj1, &val2);
50389 if (!SWIG_IsOK(ecode2)) {
50390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50391 }
50392 arg2 = static_cast< int >(val2);
50393 ecode3 = SWIG_AsVal_int(obj2, &val3);
50394 if (!SWIG_IsOK(ecode3)) {
50395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50396 }
50397 arg3 = static_cast< int >(val3);
50398 {
50399 PyThreadState* __tstate = wxPyBeginAllowThreads();
50400 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50401 wxPyEndAllowThreads(__tstate);
50402 if (PyErr_Occurred()) SWIG_fail;
50403 }
50404 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50412 PyObject *resultobj = 0;
50413 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50414 wxSize result;
50415 void *argp1 = 0 ;
50416 int res1 = 0 ;
50417 PyObject *swig_obj[1] ;
50418
50419 if (!args) SWIG_fail;
50420 swig_obj[0] = args;
50421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50422 if (!SWIG_IsOK(res1)) {
50423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50424 }
50425 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50426 {
50427 PyThreadState* __tstate = wxPyBeginAllowThreads();
50428 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50429 wxPyEndAllowThreads(__tstate);
50430 if (PyErr_Occurred()) SWIG_fail;
50431 }
50432 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50433 return resultobj;
50434 fail:
50435 return NULL;
50436 }
50437
50438
50439 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50440 PyObject *resultobj = 0;
50441 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50442 wxSize *arg2 = 0 ;
50443 void *argp1 = 0 ;
50444 int res1 = 0 ;
50445 wxSize temp2 ;
50446 PyObject * obj0 = 0 ;
50447 PyObject * obj1 = 0 ;
50448 char * kwnames[] = {
50449 (char *) "self",(char *) "sz", NULL
50450 };
50451
50452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50454 if (!SWIG_IsOK(res1)) {
50455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50456 }
50457 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50458 {
50459 arg2 = &temp2;
50460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50461 }
50462 {
50463 PyThreadState* __tstate = wxPyBeginAllowThreads();
50464 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50465 wxPyEndAllowThreads(__tstate);
50466 if (PyErr_Occurred()) SWIG_fail;
50467 }
50468 resultobj = SWIG_Py_Void();
50469 return resultobj;
50470 fail:
50471 return NULL;
50472 }
50473
50474
50475 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50476 PyObject *resultobj = 0;
50477 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50478 wxWindow *arg2 = (wxWindow *) 0 ;
50479 wxGBPosition result;
50480 void *argp1 = 0 ;
50481 int res1 = 0 ;
50482 void *argp2 = 0 ;
50483 int res2 = 0 ;
50484
50485 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50487 if (!SWIG_IsOK(res1)) {
50488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50489 }
50490 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50491 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50492 if (!SWIG_IsOK(res2)) {
50493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50494 }
50495 arg2 = reinterpret_cast< wxWindow * >(argp2);
50496 {
50497 PyThreadState* __tstate = wxPyBeginAllowThreads();
50498 result = (arg1)->GetItemPosition(arg2);
50499 wxPyEndAllowThreads(__tstate);
50500 if (PyErr_Occurred()) SWIG_fail;
50501 }
50502 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50503 return resultobj;
50504 fail:
50505 return NULL;
50506 }
50507
50508
50509 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50510 PyObject *resultobj = 0;
50511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50512 wxSizer *arg2 = (wxSizer *) 0 ;
50513 wxGBPosition result;
50514 void *argp1 = 0 ;
50515 int res1 = 0 ;
50516 void *argp2 = 0 ;
50517 int res2 = 0 ;
50518
50519 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50521 if (!SWIG_IsOK(res1)) {
50522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50523 }
50524 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50525 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50526 if (!SWIG_IsOK(res2)) {
50527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50528 }
50529 arg2 = reinterpret_cast< wxSizer * >(argp2);
50530 {
50531 PyThreadState* __tstate = wxPyBeginAllowThreads();
50532 result = (arg1)->GetItemPosition(arg2);
50533 wxPyEndAllowThreads(__tstate);
50534 if (PyErr_Occurred()) SWIG_fail;
50535 }
50536 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50537 return resultobj;
50538 fail:
50539 return NULL;
50540 }
50541
50542
50543 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50544 PyObject *resultobj = 0;
50545 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50546 size_t arg2 ;
50547 wxGBPosition result;
50548 void *argp1 = 0 ;
50549 int res1 = 0 ;
50550 size_t val2 ;
50551 int ecode2 = 0 ;
50552
50553 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50555 if (!SWIG_IsOK(res1)) {
50556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50557 }
50558 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50559 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50560 if (!SWIG_IsOK(ecode2)) {
50561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50562 }
50563 arg2 = static_cast< size_t >(val2);
50564 {
50565 PyThreadState* __tstate = wxPyBeginAllowThreads();
50566 result = (arg1)->GetItemPosition(arg2);
50567 wxPyEndAllowThreads(__tstate);
50568 if (PyErr_Occurred()) SWIG_fail;
50569 }
50570 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50571 return resultobj;
50572 fail:
50573 return NULL;
50574 }
50575
50576
50577 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50578 int argc;
50579 PyObject *argv[3];
50580
50581 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50582 --argc;
50583 if (argc == 2) {
50584 int _v = 0;
50585 {
50586 void *vptr = 0;
50587 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50588 _v = SWIG_CheckState(res);
50589 }
50590 if (!_v) goto check_1;
50591 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50592 }
50593 check_1:
50594
50595 if (argc == 2) {
50596 int _v = 0;
50597 {
50598 void *vptr = 0;
50599 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50600 _v = SWIG_CheckState(res);
50601 }
50602 if (!_v) goto check_2;
50603 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50604 }
50605 check_2:
50606
50607 if (argc == 2) {
50608 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50609 }
50610
50611 fail:
50612 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50618 PyObject *resultobj = 0;
50619 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50620 wxWindow *arg2 = (wxWindow *) 0 ;
50621 wxGBPosition *arg3 = 0 ;
50622 bool result;
50623 void *argp1 = 0 ;
50624 int res1 = 0 ;
50625 void *argp2 = 0 ;
50626 int res2 = 0 ;
50627 wxGBPosition temp3 ;
50628
50629 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50631 if (!SWIG_IsOK(res1)) {
50632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50633 }
50634 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50635 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50636 if (!SWIG_IsOK(res2)) {
50637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50638 }
50639 arg2 = reinterpret_cast< wxWindow * >(argp2);
50640 {
50641 arg3 = &temp3;
50642 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50643 }
50644 {
50645 PyThreadState* __tstate = wxPyBeginAllowThreads();
50646 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50647 wxPyEndAllowThreads(__tstate);
50648 if (PyErr_Occurred()) SWIG_fail;
50649 }
50650 {
50651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50652 }
50653 return resultobj;
50654 fail:
50655 return NULL;
50656 }
50657
50658
50659 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50660 PyObject *resultobj = 0;
50661 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50662 wxSizer *arg2 = (wxSizer *) 0 ;
50663 wxGBPosition *arg3 = 0 ;
50664 bool result;
50665 void *argp1 = 0 ;
50666 int res1 = 0 ;
50667 void *argp2 = 0 ;
50668 int res2 = 0 ;
50669 wxGBPosition temp3 ;
50670
50671 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50673 if (!SWIG_IsOK(res1)) {
50674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50675 }
50676 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50677 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50678 if (!SWIG_IsOK(res2)) {
50679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50680 }
50681 arg2 = reinterpret_cast< wxSizer * >(argp2);
50682 {
50683 arg3 = &temp3;
50684 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50685 }
50686 {
50687 PyThreadState* __tstate = wxPyBeginAllowThreads();
50688 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50689 wxPyEndAllowThreads(__tstate);
50690 if (PyErr_Occurred()) SWIG_fail;
50691 }
50692 {
50693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50694 }
50695 return resultobj;
50696 fail:
50697 return NULL;
50698 }
50699
50700
50701 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50702 PyObject *resultobj = 0;
50703 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50704 size_t arg2 ;
50705 wxGBPosition *arg3 = 0 ;
50706 bool result;
50707 void *argp1 = 0 ;
50708 int res1 = 0 ;
50709 size_t val2 ;
50710 int ecode2 = 0 ;
50711 wxGBPosition temp3 ;
50712
50713 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
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_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50717 }
50718 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50719 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50720 if (!SWIG_IsOK(ecode2)) {
50721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50722 }
50723 arg2 = static_cast< size_t >(val2);
50724 {
50725 arg3 = &temp3;
50726 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50727 }
50728 {
50729 PyThreadState* __tstate = wxPyBeginAllowThreads();
50730 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50731 wxPyEndAllowThreads(__tstate);
50732 if (PyErr_Occurred()) SWIG_fail;
50733 }
50734 {
50735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50736 }
50737 return resultobj;
50738 fail:
50739 return NULL;
50740 }
50741
50742
50743 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50744 int argc;
50745 PyObject *argv[4];
50746
50747 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50748 --argc;
50749 if (argc == 3) {
50750 int _v = 0;
50751 {
50752 void *vptr = 0;
50753 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50754 _v = SWIG_CheckState(res);
50755 }
50756 if (!_v) goto check_1;
50757 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50758 }
50759 check_1:
50760
50761 if (argc == 3) {
50762 int _v = 0;
50763 {
50764 void *vptr = 0;
50765 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50766 _v = SWIG_CheckState(res);
50767 }
50768 if (!_v) goto check_2;
50769 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50770 }
50771 check_2:
50772
50773 if (argc == 3) {
50774 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50775 }
50776
50777 fail:
50778 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50779 return NULL;
50780 }
50781
50782
50783 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50784 PyObject *resultobj = 0;
50785 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50786 wxWindow *arg2 = (wxWindow *) 0 ;
50787 wxGBSpan result;
50788 void *argp1 = 0 ;
50789 int res1 = 0 ;
50790 void *argp2 = 0 ;
50791 int res2 = 0 ;
50792
50793 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50795 if (!SWIG_IsOK(res1)) {
50796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50797 }
50798 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50799 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50800 if (!SWIG_IsOK(res2)) {
50801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50802 }
50803 arg2 = reinterpret_cast< wxWindow * >(argp2);
50804 {
50805 PyThreadState* __tstate = wxPyBeginAllowThreads();
50806 result = (arg1)->GetItemSpan(arg2);
50807 wxPyEndAllowThreads(__tstate);
50808 if (PyErr_Occurred()) SWIG_fail;
50809 }
50810 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50811 return resultobj;
50812 fail:
50813 return NULL;
50814 }
50815
50816
50817 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50818 PyObject *resultobj = 0;
50819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50820 wxSizer *arg2 = (wxSizer *) 0 ;
50821 wxGBSpan result;
50822 void *argp1 = 0 ;
50823 int res1 = 0 ;
50824 void *argp2 = 0 ;
50825 int res2 = 0 ;
50826
50827 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50829 if (!SWIG_IsOK(res1)) {
50830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50831 }
50832 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50833 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50834 if (!SWIG_IsOK(res2)) {
50835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50836 }
50837 arg2 = reinterpret_cast< wxSizer * >(argp2);
50838 {
50839 PyThreadState* __tstate = wxPyBeginAllowThreads();
50840 result = (arg1)->GetItemSpan(arg2);
50841 wxPyEndAllowThreads(__tstate);
50842 if (PyErr_Occurred()) SWIG_fail;
50843 }
50844 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50845 return resultobj;
50846 fail:
50847 return NULL;
50848 }
50849
50850
50851 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50852 PyObject *resultobj = 0;
50853 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50854 size_t arg2 ;
50855 wxGBSpan result;
50856 void *argp1 = 0 ;
50857 int res1 = 0 ;
50858 size_t val2 ;
50859 int ecode2 = 0 ;
50860
50861 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50863 if (!SWIG_IsOK(res1)) {
50864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50865 }
50866 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50867 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50868 if (!SWIG_IsOK(ecode2)) {
50869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50870 }
50871 arg2 = static_cast< size_t >(val2);
50872 {
50873 PyThreadState* __tstate = wxPyBeginAllowThreads();
50874 result = (arg1)->GetItemSpan(arg2);
50875 wxPyEndAllowThreads(__tstate);
50876 if (PyErr_Occurred()) SWIG_fail;
50877 }
50878 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50879 return resultobj;
50880 fail:
50881 return NULL;
50882 }
50883
50884
50885 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50886 int argc;
50887 PyObject *argv[3];
50888
50889 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50890 --argc;
50891 if (argc == 2) {
50892 int _v = 0;
50893 {
50894 void *vptr = 0;
50895 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50896 _v = SWIG_CheckState(res);
50897 }
50898 if (!_v) goto check_1;
50899 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50900 }
50901 check_1:
50902
50903 if (argc == 2) {
50904 int _v = 0;
50905 {
50906 void *vptr = 0;
50907 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50908 _v = SWIG_CheckState(res);
50909 }
50910 if (!_v) goto check_2;
50911 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50912 }
50913 check_2:
50914
50915 if (argc == 2) {
50916 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50917 }
50918
50919 fail:
50920 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50921 return NULL;
50922 }
50923
50924
50925 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50926 PyObject *resultobj = 0;
50927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50928 wxWindow *arg2 = (wxWindow *) 0 ;
50929 wxGBSpan *arg3 = 0 ;
50930 bool result;
50931 void *argp1 = 0 ;
50932 int res1 = 0 ;
50933 void *argp2 = 0 ;
50934 int res2 = 0 ;
50935 wxGBSpan temp3 ;
50936
50937 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50939 if (!SWIG_IsOK(res1)) {
50940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50941 }
50942 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50943 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50944 if (!SWIG_IsOK(res2)) {
50945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50946 }
50947 arg2 = reinterpret_cast< wxWindow * >(argp2);
50948 {
50949 arg3 = &temp3;
50950 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50951 }
50952 {
50953 PyThreadState* __tstate = wxPyBeginAllowThreads();
50954 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50955 wxPyEndAllowThreads(__tstate);
50956 if (PyErr_Occurred()) SWIG_fail;
50957 }
50958 {
50959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50960 }
50961 return resultobj;
50962 fail:
50963 return NULL;
50964 }
50965
50966
50967 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50968 PyObject *resultobj = 0;
50969 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50970 wxSizer *arg2 = (wxSizer *) 0 ;
50971 wxGBSpan *arg3 = 0 ;
50972 bool result;
50973 void *argp1 = 0 ;
50974 int res1 = 0 ;
50975 void *argp2 = 0 ;
50976 int res2 = 0 ;
50977 wxGBSpan temp3 ;
50978
50979 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50981 if (!SWIG_IsOK(res1)) {
50982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50983 }
50984 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50985 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50986 if (!SWIG_IsOK(res2)) {
50987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50988 }
50989 arg2 = reinterpret_cast< wxSizer * >(argp2);
50990 {
50991 arg3 = &temp3;
50992 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50993 }
50994 {
50995 PyThreadState* __tstate = wxPyBeginAllowThreads();
50996 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50997 wxPyEndAllowThreads(__tstate);
50998 if (PyErr_Occurred()) SWIG_fail;
50999 }
51000 {
51001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51002 }
51003 return resultobj;
51004 fail:
51005 return NULL;
51006 }
51007
51008
51009 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51010 PyObject *resultobj = 0;
51011 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51012 size_t arg2 ;
51013 wxGBSpan *arg3 = 0 ;
51014 bool result;
51015 void *argp1 = 0 ;
51016 int res1 = 0 ;
51017 size_t val2 ;
51018 int ecode2 = 0 ;
51019 wxGBSpan temp3 ;
51020
51021 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51023 if (!SWIG_IsOK(res1)) {
51024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51025 }
51026 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51027 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51028 if (!SWIG_IsOK(ecode2)) {
51029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51030 }
51031 arg2 = static_cast< size_t >(val2);
51032 {
51033 arg3 = &temp3;
51034 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51035 }
51036 {
51037 PyThreadState* __tstate = wxPyBeginAllowThreads();
51038 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51039 wxPyEndAllowThreads(__tstate);
51040 if (PyErr_Occurred()) SWIG_fail;
51041 }
51042 {
51043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51044 }
51045 return resultobj;
51046 fail:
51047 return NULL;
51048 }
51049
51050
51051 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51052 int argc;
51053 PyObject *argv[4];
51054
51055 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51056 --argc;
51057 if (argc == 3) {
51058 int _v = 0;
51059 {
51060 void *vptr = 0;
51061 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51062 _v = SWIG_CheckState(res);
51063 }
51064 if (!_v) goto check_1;
51065 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51066 }
51067 check_1:
51068
51069 if (argc == 3) {
51070 int _v = 0;
51071 {
51072 void *vptr = 0;
51073 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51074 _v = SWIG_CheckState(res);
51075 }
51076 if (!_v) goto check_2;
51077 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51078 }
51079 check_2:
51080
51081 if (argc == 3) {
51082 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51083 }
51084
51085 fail:
51086 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51087 return NULL;
51088 }
51089
51090
51091 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51092 PyObject *resultobj = 0;
51093 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51094 wxWindow *arg2 = (wxWindow *) 0 ;
51095 wxGBSizerItem *result = 0 ;
51096 void *argp1 = 0 ;
51097 int res1 = 0 ;
51098 void *argp2 = 0 ;
51099 int res2 = 0 ;
51100
51101 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51103 if (!SWIG_IsOK(res1)) {
51104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51105 }
51106 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51107 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51108 if (!SWIG_IsOK(res2)) {
51109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51110 }
51111 arg2 = reinterpret_cast< wxWindow * >(argp2);
51112 {
51113 PyThreadState* __tstate = wxPyBeginAllowThreads();
51114 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51115 wxPyEndAllowThreads(__tstate);
51116 if (PyErr_Occurred()) SWIG_fail;
51117 }
51118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51119 return resultobj;
51120 fail:
51121 return NULL;
51122 }
51123
51124
51125 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51126 PyObject *resultobj = 0;
51127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51128 wxSizer *arg2 = (wxSizer *) 0 ;
51129 wxGBSizerItem *result = 0 ;
51130 void *argp1 = 0 ;
51131 int res1 = 0 ;
51132 void *argp2 = 0 ;
51133 int res2 = 0 ;
51134
51135 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51137 if (!SWIG_IsOK(res1)) {
51138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51139 }
51140 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51141 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51142 if (!SWIG_IsOK(res2)) {
51143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51144 }
51145 arg2 = reinterpret_cast< wxSizer * >(argp2);
51146 {
51147 PyThreadState* __tstate = wxPyBeginAllowThreads();
51148 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51149 wxPyEndAllowThreads(__tstate);
51150 if (PyErr_Occurred()) SWIG_fail;
51151 }
51152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51153 return resultobj;
51154 fail:
51155 return NULL;
51156 }
51157
51158
51159 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51160 int argc;
51161 PyObject *argv[3];
51162
51163 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51164 --argc;
51165 if (argc == 2) {
51166 int _v = 0;
51167 {
51168 void *vptr = 0;
51169 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51170 _v = SWIG_CheckState(res);
51171 }
51172 if (!_v) goto check_1;
51173 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51174 }
51175 check_1:
51176
51177 if (argc == 2) {
51178 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51179 }
51180
51181 fail:
51182 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51183 return NULL;
51184 }
51185
51186
51187 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51188 PyObject *resultobj = 0;
51189 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51190 wxGBPosition *arg2 = 0 ;
51191 wxGBSizerItem *result = 0 ;
51192 void *argp1 = 0 ;
51193 int res1 = 0 ;
51194 wxGBPosition temp2 ;
51195 PyObject * obj0 = 0 ;
51196 PyObject * obj1 = 0 ;
51197 char * kwnames[] = {
51198 (char *) "self",(char *) "pos", NULL
51199 };
51200
51201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51203 if (!SWIG_IsOK(res1)) {
51204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51205 }
51206 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51207 {
51208 arg2 = &temp2;
51209 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51210 }
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51227 wxPoint *arg2 = 0 ;
51228 wxGBSizerItem *result = 0 ;
51229 void *argp1 = 0 ;
51230 int res1 = 0 ;
51231 wxPoint temp2 ;
51232 PyObject * obj0 = 0 ;
51233 PyObject * obj1 = 0 ;
51234 char * kwnames[] = {
51235 (char *) "self",(char *) "pt", NULL
51236 };
51237
51238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51240 if (!SWIG_IsOK(res1)) {
51241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51242 }
51243 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51244 {
51245 arg2 = &temp2;
51246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51247 }
51248 {
51249 PyThreadState* __tstate = wxPyBeginAllowThreads();
51250 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51251 wxPyEndAllowThreads(__tstate);
51252 if (PyErr_Occurred()) SWIG_fail;
51253 }
51254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51255 return resultobj;
51256 fail:
51257 return NULL;
51258 }
51259
51260
51261 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51262 PyObject *resultobj = 0;
51263 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51264 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51265 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51266 bool result;
51267 void *argp1 = 0 ;
51268 int res1 = 0 ;
51269 void *argp2 = 0 ;
51270 int res2 = 0 ;
51271 void *argp3 = 0 ;
51272 int res3 = 0 ;
51273 PyObject * obj0 = 0 ;
51274 PyObject * obj1 = 0 ;
51275 PyObject * obj2 = 0 ;
51276 char * kwnames[] = {
51277 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51278 };
51279
51280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51282 if (!SWIG_IsOK(res1)) {
51283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51284 }
51285 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51287 if (!SWIG_IsOK(res2)) {
51288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51289 }
51290 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51291 if (obj2) {
51292 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51293 if (!SWIG_IsOK(res3)) {
51294 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51295 }
51296 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51297 }
51298 {
51299 PyThreadState* __tstate = wxPyBeginAllowThreads();
51300 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51301 wxPyEndAllowThreads(__tstate);
51302 if (PyErr_Occurred()) SWIG_fail;
51303 }
51304 {
51305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51306 }
51307 return resultobj;
51308 fail:
51309 return NULL;
51310 }
51311
51312
51313 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51314 PyObject *resultobj = 0;
51315 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51316 wxGBPosition *arg2 = 0 ;
51317 wxGBSpan *arg3 = 0 ;
51318 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51319 bool result;
51320 void *argp1 = 0 ;
51321 int res1 = 0 ;
51322 wxGBPosition temp2 ;
51323 wxGBSpan temp3 ;
51324 void *argp4 = 0 ;
51325 int res4 = 0 ;
51326 PyObject * obj0 = 0 ;
51327 PyObject * obj1 = 0 ;
51328 PyObject * obj2 = 0 ;
51329 PyObject * obj3 = 0 ;
51330 char * kwnames[] = {
51331 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51332 };
51333
51334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51336 if (!SWIG_IsOK(res1)) {
51337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51338 }
51339 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51340 {
51341 arg2 = &temp2;
51342 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51343 }
51344 {
51345 arg3 = &temp3;
51346 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51347 }
51348 if (obj3) {
51349 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51350 if (!SWIG_IsOK(res4)) {
51351 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51352 }
51353 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51354 }
51355 {
51356 PyThreadState* __tstate = wxPyBeginAllowThreads();
51357 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51358 wxPyEndAllowThreads(__tstate);
51359 if (PyErr_Occurred()) SWIG_fail;
51360 }
51361 {
51362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51363 }
51364 return resultobj;
51365 fail:
51366 return NULL;
51367 }
51368
51369
51370 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51371 PyObject *obj;
51372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51373 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51374 return SWIG_Py_Void();
51375 }
51376
51377 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51378 return SWIG_Python_InitShadowInstance(args);
51379 }
51380
51381 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51382 PyObject *resultobj = 0;
51383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51384 wxRelationship arg2 ;
51385 wxWindow *arg3 = (wxWindow *) 0 ;
51386 wxEdge arg4 ;
51387 int arg5 = (int) 0 ;
51388 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51389 void *argp1 = 0 ;
51390 int res1 = 0 ;
51391 int val2 ;
51392 int ecode2 = 0 ;
51393 void *argp3 = 0 ;
51394 int res3 = 0 ;
51395 int val4 ;
51396 int ecode4 = 0 ;
51397 int val5 ;
51398 int ecode5 = 0 ;
51399 int val6 ;
51400 int ecode6 = 0 ;
51401 PyObject * obj0 = 0 ;
51402 PyObject * obj1 = 0 ;
51403 PyObject * obj2 = 0 ;
51404 PyObject * obj3 = 0 ;
51405 PyObject * obj4 = 0 ;
51406 PyObject * obj5 = 0 ;
51407 char * kwnames[] = {
51408 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51409 };
51410
51411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51413 if (!SWIG_IsOK(res1)) {
51414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51415 }
51416 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51417 ecode2 = SWIG_AsVal_int(obj1, &val2);
51418 if (!SWIG_IsOK(ecode2)) {
51419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51420 }
51421 arg2 = static_cast< wxRelationship >(val2);
51422 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51423 if (!SWIG_IsOK(res3)) {
51424 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51425 }
51426 arg3 = reinterpret_cast< wxWindow * >(argp3);
51427 ecode4 = SWIG_AsVal_int(obj3, &val4);
51428 if (!SWIG_IsOK(ecode4)) {
51429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51430 }
51431 arg4 = static_cast< wxEdge >(val4);
51432 if (obj4) {
51433 ecode5 = SWIG_AsVal_int(obj4, &val5);
51434 if (!SWIG_IsOK(ecode5)) {
51435 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51436 }
51437 arg5 = static_cast< int >(val5);
51438 }
51439 if (obj5) {
51440 ecode6 = SWIG_AsVal_int(obj5, &val6);
51441 if (!SWIG_IsOK(ecode6)) {
51442 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51443 }
51444 arg6 = static_cast< int >(val6);
51445 }
51446 {
51447 PyThreadState* __tstate = wxPyBeginAllowThreads();
51448 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51449 wxPyEndAllowThreads(__tstate);
51450 if (PyErr_Occurred()) SWIG_fail;
51451 }
51452 resultobj = SWIG_Py_Void();
51453 return resultobj;
51454 fail:
51455 return NULL;
51456 }
51457
51458
51459 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51460 PyObject *resultobj = 0;
51461 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51462 wxWindow *arg2 = (wxWindow *) 0 ;
51463 int arg3 = (int) 0 ;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 void *argp2 = 0 ;
51467 int res2 = 0 ;
51468 int val3 ;
51469 int ecode3 = 0 ;
51470 PyObject * obj0 = 0 ;
51471 PyObject * obj1 = 0 ;
51472 PyObject * obj2 = 0 ;
51473 char * kwnames[] = {
51474 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51475 };
51476
51477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51479 if (!SWIG_IsOK(res1)) {
51480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51481 }
51482 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51483 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51484 if (!SWIG_IsOK(res2)) {
51485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51486 }
51487 arg2 = reinterpret_cast< wxWindow * >(argp2);
51488 if (obj2) {
51489 ecode3 = SWIG_AsVal_int(obj2, &val3);
51490 if (!SWIG_IsOK(ecode3)) {
51491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51492 }
51493 arg3 = static_cast< int >(val3);
51494 }
51495 {
51496 PyThreadState* __tstate = wxPyBeginAllowThreads();
51497 (arg1)->LeftOf(arg2,arg3);
51498 wxPyEndAllowThreads(__tstate);
51499 if (PyErr_Occurred()) SWIG_fail;
51500 }
51501 resultobj = SWIG_Py_Void();
51502 return resultobj;
51503 fail:
51504 return NULL;
51505 }
51506
51507
51508 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51509 PyObject *resultobj = 0;
51510 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51511 wxWindow *arg2 = (wxWindow *) 0 ;
51512 int arg3 = (int) 0 ;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 void *argp2 = 0 ;
51516 int res2 = 0 ;
51517 int val3 ;
51518 int ecode3 = 0 ;
51519 PyObject * obj0 = 0 ;
51520 PyObject * obj1 = 0 ;
51521 PyObject * obj2 = 0 ;
51522 char * kwnames[] = {
51523 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51524 };
51525
51526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51528 if (!SWIG_IsOK(res1)) {
51529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51530 }
51531 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51533 if (!SWIG_IsOK(res2)) {
51534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51535 }
51536 arg2 = reinterpret_cast< wxWindow * >(argp2);
51537 if (obj2) {
51538 ecode3 = SWIG_AsVal_int(obj2, &val3);
51539 if (!SWIG_IsOK(ecode3)) {
51540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51541 }
51542 arg3 = static_cast< int >(val3);
51543 }
51544 {
51545 PyThreadState* __tstate = wxPyBeginAllowThreads();
51546 (arg1)->RightOf(arg2,arg3);
51547 wxPyEndAllowThreads(__tstate);
51548 if (PyErr_Occurred()) SWIG_fail;
51549 }
51550 resultobj = SWIG_Py_Void();
51551 return resultobj;
51552 fail:
51553 return NULL;
51554 }
51555
51556
51557 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51558 PyObject *resultobj = 0;
51559 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51560 wxWindow *arg2 = (wxWindow *) 0 ;
51561 int arg3 = (int) 0 ;
51562 void *argp1 = 0 ;
51563 int res1 = 0 ;
51564 void *argp2 = 0 ;
51565 int res2 = 0 ;
51566 int val3 ;
51567 int ecode3 = 0 ;
51568 PyObject * obj0 = 0 ;
51569 PyObject * obj1 = 0 ;
51570 PyObject * obj2 = 0 ;
51571 char * kwnames[] = {
51572 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51573 };
51574
51575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51577 if (!SWIG_IsOK(res1)) {
51578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51579 }
51580 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51582 if (!SWIG_IsOK(res2)) {
51583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51584 }
51585 arg2 = reinterpret_cast< wxWindow * >(argp2);
51586 if (obj2) {
51587 ecode3 = SWIG_AsVal_int(obj2, &val3);
51588 if (!SWIG_IsOK(ecode3)) {
51589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51590 }
51591 arg3 = static_cast< int >(val3);
51592 }
51593 {
51594 PyThreadState* __tstate = wxPyBeginAllowThreads();
51595 (arg1)->Above(arg2,arg3);
51596 wxPyEndAllowThreads(__tstate);
51597 if (PyErr_Occurred()) SWIG_fail;
51598 }
51599 resultobj = SWIG_Py_Void();
51600 return resultobj;
51601 fail:
51602 return NULL;
51603 }
51604
51605
51606 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51607 PyObject *resultobj = 0;
51608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51609 wxWindow *arg2 = (wxWindow *) 0 ;
51610 int arg3 = (int) 0 ;
51611 void *argp1 = 0 ;
51612 int res1 = 0 ;
51613 void *argp2 = 0 ;
51614 int res2 = 0 ;
51615 int val3 ;
51616 int ecode3 = 0 ;
51617 PyObject * obj0 = 0 ;
51618 PyObject * obj1 = 0 ;
51619 PyObject * obj2 = 0 ;
51620 char * kwnames[] = {
51621 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51622 };
51623
51624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51626 if (!SWIG_IsOK(res1)) {
51627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51628 }
51629 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51630 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51631 if (!SWIG_IsOK(res2)) {
51632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51633 }
51634 arg2 = reinterpret_cast< wxWindow * >(argp2);
51635 if (obj2) {
51636 ecode3 = SWIG_AsVal_int(obj2, &val3);
51637 if (!SWIG_IsOK(ecode3)) {
51638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51639 }
51640 arg3 = static_cast< int >(val3);
51641 }
51642 {
51643 PyThreadState* __tstate = wxPyBeginAllowThreads();
51644 (arg1)->Below(arg2,arg3);
51645 wxPyEndAllowThreads(__tstate);
51646 if (PyErr_Occurred()) SWIG_fail;
51647 }
51648 resultobj = SWIG_Py_Void();
51649 return resultobj;
51650 fail:
51651 return NULL;
51652 }
51653
51654
51655 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51656 PyObject *resultobj = 0;
51657 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51658 wxWindow *arg2 = (wxWindow *) 0 ;
51659 wxEdge arg3 ;
51660 int arg4 = (int) 0 ;
51661 void *argp1 = 0 ;
51662 int res1 = 0 ;
51663 void *argp2 = 0 ;
51664 int res2 = 0 ;
51665 int val3 ;
51666 int ecode3 = 0 ;
51667 int val4 ;
51668 int ecode4 = 0 ;
51669 PyObject * obj0 = 0 ;
51670 PyObject * obj1 = 0 ;
51671 PyObject * obj2 = 0 ;
51672 PyObject * obj3 = 0 ;
51673 char * kwnames[] = {
51674 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51675 };
51676
51677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51679 if (!SWIG_IsOK(res1)) {
51680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51681 }
51682 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51683 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51684 if (!SWIG_IsOK(res2)) {
51685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51686 }
51687 arg2 = reinterpret_cast< wxWindow * >(argp2);
51688 ecode3 = SWIG_AsVal_int(obj2, &val3);
51689 if (!SWIG_IsOK(ecode3)) {
51690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51691 }
51692 arg3 = static_cast< wxEdge >(val3);
51693 if (obj3) {
51694 ecode4 = SWIG_AsVal_int(obj3, &val4);
51695 if (!SWIG_IsOK(ecode4)) {
51696 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51697 }
51698 arg4 = static_cast< int >(val4);
51699 }
51700 {
51701 PyThreadState* __tstate = wxPyBeginAllowThreads();
51702 (arg1)->SameAs(arg2,arg3,arg4);
51703 wxPyEndAllowThreads(__tstate);
51704 if (PyErr_Occurred()) SWIG_fail;
51705 }
51706 resultobj = SWIG_Py_Void();
51707 return resultobj;
51708 fail:
51709 return NULL;
51710 }
51711
51712
51713 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51714 PyObject *resultobj = 0;
51715 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51716 wxWindow *arg2 = (wxWindow *) 0 ;
51717 wxEdge arg3 ;
51718 int arg4 ;
51719 void *argp1 = 0 ;
51720 int res1 = 0 ;
51721 void *argp2 = 0 ;
51722 int res2 = 0 ;
51723 int val3 ;
51724 int ecode3 = 0 ;
51725 int val4 ;
51726 int ecode4 = 0 ;
51727 PyObject * obj0 = 0 ;
51728 PyObject * obj1 = 0 ;
51729 PyObject * obj2 = 0 ;
51730 PyObject * obj3 = 0 ;
51731 char * kwnames[] = {
51732 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51733 };
51734
51735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51737 if (!SWIG_IsOK(res1)) {
51738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51739 }
51740 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51742 if (!SWIG_IsOK(res2)) {
51743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51744 }
51745 arg2 = reinterpret_cast< wxWindow * >(argp2);
51746 ecode3 = SWIG_AsVal_int(obj2, &val3);
51747 if (!SWIG_IsOK(ecode3)) {
51748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51749 }
51750 arg3 = static_cast< wxEdge >(val3);
51751 ecode4 = SWIG_AsVal_int(obj3, &val4);
51752 if (!SWIG_IsOK(ecode4)) {
51753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51754 }
51755 arg4 = static_cast< int >(val4);
51756 {
51757 PyThreadState* __tstate = wxPyBeginAllowThreads();
51758 (arg1)->PercentOf(arg2,arg3,arg4);
51759 wxPyEndAllowThreads(__tstate);
51760 if (PyErr_Occurred()) SWIG_fail;
51761 }
51762 resultobj = SWIG_Py_Void();
51763 return resultobj;
51764 fail:
51765 return NULL;
51766 }
51767
51768
51769 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51770 PyObject *resultobj = 0;
51771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51772 int arg2 ;
51773 void *argp1 = 0 ;
51774 int res1 = 0 ;
51775 int val2 ;
51776 int ecode2 = 0 ;
51777 PyObject * obj0 = 0 ;
51778 PyObject * obj1 = 0 ;
51779 char * kwnames[] = {
51780 (char *) "self",(char *) "val", NULL
51781 };
51782
51783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51785 if (!SWIG_IsOK(res1)) {
51786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51787 }
51788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51789 ecode2 = SWIG_AsVal_int(obj1, &val2);
51790 if (!SWIG_IsOK(ecode2)) {
51791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51792 }
51793 arg2 = static_cast< int >(val2);
51794 {
51795 PyThreadState* __tstate = wxPyBeginAllowThreads();
51796 (arg1)->Absolute(arg2);
51797 wxPyEndAllowThreads(__tstate);
51798 if (PyErr_Occurred()) SWIG_fail;
51799 }
51800 resultobj = SWIG_Py_Void();
51801 return resultobj;
51802 fail:
51803 return NULL;
51804 }
51805
51806
51807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51808 PyObject *resultobj = 0;
51809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51810 void *argp1 = 0 ;
51811 int res1 = 0 ;
51812 PyObject *swig_obj[1] ;
51813
51814 if (!args) SWIG_fail;
51815 swig_obj[0] = args;
51816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51817 if (!SWIG_IsOK(res1)) {
51818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51819 }
51820 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 (arg1)->Unconstrained();
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 resultobj = SWIG_Py_Void();
51828 return resultobj;
51829 fail:
51830 return NULL;
51831 }
51832
51833
51834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51835 PyObject *resultobj = 0;
51836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51837 void *argp1 = 0 ;
51838 int res1 = 0 ;
51839 PyObject *swig_obj[1] ;
51840
51841 if (!args) SWIG_fail;
51842 swig_obj[0] = args;
51843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51844 if (!SWIG_IsOK(res1)) {
51845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51846 }
51847 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51848 {
51849 PyThreadState* __tstate = wxPyBeginAllowThreads();
51850 (arg1)->AsIs();
51851 wxPyEndAllowThreads(__tstate);
51852 if (PyErr_Occurred()) SWIG_fail;
51853 }
51854 resultobj = SWIG_Py_Void();
51855 return resultobj;
51856 fail:
51857 return NULL;
51858 }
51859
51860
51861 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51862 PyObject *resultobj = 0;
51863 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51864 wxWindow *result = 0 ;
51865 void *argp1 = 0 ;
51866 int res1 = 0 ;
51867 PyObject *swig_obj[1] ;
51868
51869 if (!args) SWIG_fail;
51870 swig_obj[0] = args;
51871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51872 if (!SWIG_IsOK(res1)) {
51873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51874 }
51875 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 result = (wxWindow *)(arg1)->GetOtherWindow();
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 {
51883 resultobj = wxPyMake_wxObject(result, 0);
51884 }
51885 return resultobj;
51886 fail:
51887 return NULL;
51888 }
51889
51890
51891 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51892 PyObject *resultobj = 0;
51893 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51894 wxEdge result;
51895 void *argp1 = 0 ;
51896 int res1 = 0 ;
51897 PyObject *swig_obj[1] ;
51898
51899 if (!args) SWIG_fail;
51900 swig_obj[0] = args;
51901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51902 if (!SWIG_IsOK(res1)) {
51903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51904 }
51905 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51906 {
51907 PyThreadState* __tstate = wxPyBeginAllowThreads();
51908 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51909 wxPyEndAllowThreads(__tstate);
51910 if (PyErr_Occurred()) SWIG_fail;
51911 }
51912 resultobj = SWIG_From_int(static_cast< int >(result));
51913 return resultobj;
51914 fail:
51915 return NULL;
51916 }
51917
51918
51919 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51920 PyObject *resultobj = 0;
51921 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51922 wxEdge arg2 ;
51923 void *argp1 = 0 ;
51924 int res1 = 0 ;
51925 int val2 ;
51926 int ecode2 = 0 ;
51927 PyObject * obj0 = 0 ;
51928 PyObject * obj1 = 0 ;
51929 char * kwnames[] = {
51930 (char *) "self",(char *) "which", NULL
51931 };
51932
51933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51935 if (!SWIG_IsOK(res1)) {
51936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51937 }
51938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51939 ecode2 = SWIG_AsVal_int(obj1, &val2);
51940 if (!SWIG_IsOK(ecode2)) {
51941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51942 }
51943 arg2 = static_cast< wxEdge >(val2);
51944 {
51945 PyThreadState* __tstate = wxPyBeginAllowThreads();
51946 (arg1)->SetEdge(arg2);
51947 wxPyEndAllowThreads(__tstate);
51948 if (PyErr_Occurred()) SWIG_fail;
51949 }
51950 resultobj = SWIG_Py_Void();
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51958 PyObject *resultobj = 0;
51959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51960 int arg2 ;
51961 void *argp1 = 0 ;
51962 int res1 = 0 ;
51963 int val2 ;
51964 int ecode2 = 0 ;
51965 PyObject * obj0 = 0 ;
51966 PyObject * obj1 = 0 ;
51967 char * kwnames[] = {
51968 (char *) "self",(char *) "v", NULL
51969 };
51970
51971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51973 if (!SWIG_IsOK(res1)) {
51974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51975 }
51976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51977 ecode2 = SWIG_AsVal_int(obj1, &val2);
51978 if (!SWIG_IsOK(ecode2)) {
51979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51980 }
51981 arg2 = static_cast< int >(val2);
51982 {
51983 PyThreadState* __tstate = wxPyBeginAllowThreads();
51984 (arg1)->SetValue(arg2);
51985 wxPyEndAllowThreads(__tstate);
51986 if (PyErr_Occurred()) SWIG_fail;
51987 }
51988 resultobj = SWIG_Py_Void();
51989 return resultobj;
51990 fail:
51991 return NULL;
51992 }
51993
51994
51995 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51996 PyObject *resultobj = 0;
51997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51998 int result;
51999 void *argp1 = 0 ;
52000 int res1 = 0 ;
52001 PyObject *swig_obj[1] ;
52002
52003 if (!args) SWIG_fail;
52004 swig_obj[0] = args;
52005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52008 }
52009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52010 {
52011 PyThreadState* __tstate = wxPyBeginAllowThreads();
52012 result = (int)(arg1)->GetMargin();
52013 wxPyEndAllowThreads(__tstate);
52014 if (PyErr_Occurred()) SWIG_fail;
52015 }
52016 resultobj = SWIG_From_int(static_cast< int >(result));
52017 return resultobj;
52018 fail:
52019 return NULL;
52020 }
52021
52022
52023 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52024 PyObject *resultobj = 0;
52025 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52026 int arg2 ;
52027 void *argp1 = 0 ;
52028 int res1 = 0 ;
52029 int val2 ;
52030 int ecode2 = 0 ;
52031 PyObject * obj0 = 0 ;
52032 PyObject * obj1 = 0 ;
52033 char * kwnames[] = {
52034 (char *) "self",(char *) "m", NULL
52035 };
52036
52037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52039 if (!SWIG_IsOK(res1)) {
52040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52041 }
52042 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52043 ecode2 = SWIG_AsVal_int(obj1, &val2);
52044 if (!SWIG_IsOK(ecode2)) {
52045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52046 }
52047 arg2 = static_cast< int >(val2);
52048 {
52049 PyThreadState* __tstate = wxPyBeginAllowThreads();
52050 (arg1)->SetMargin(arg2);
52051 wxPyEndAllowThreads(__tstate);
52052 if (PyErr_Occurred()) SWIG_fail;
52053 }
52054 resultobj = SWIG_Py_Void();
52055 return resultobj;
52056 fail:
52057 return NULL;
52058 }
52059
52060
52061 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52062 PyObject *resultobj = 0;
52063 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52064 int result;
52065 void *argp1 = 0 ;
52066 int res1 = 0 ;
52067 PyObject *swig_obj[1] ;
52068
52069 if (!args) SWIG_fail;
52070 swig_obj[0] = args;
52071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52072 if (!SWIG_IsOK(res1)) {
52073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52074 }
52075 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 resultobj = SWIG_From_int(static_cast< int >(result));
52083 return resultobj;
52084 fail:
52085 return NULL;
52086 }
52087
52088
52089 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52090 PyObject *resultobj = 0;
52091 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52092 int result;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 PyObject *swig_obj[1] ;
52096
52097 if (!args) SWIG_fail;
52098 swig_obj[0] = args;
52099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52100 if (!SWIG_IsOK(res1)) {
52101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52102 }
52103 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52104 {
52105 PyThreadState* __tstate = wxPyBeginAllowThreads();
52106 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52107 wxPyEndAllowThreads(__tstate);
52108 if (PyErr_Occurred()) SWIG_fail;
52109 }
52110 resultobj = SWIG_From_int(static_cast< int >(result));
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52120 int result;
52121 void *argp1 = 0 ;
52122 int res1 = 0 ;
52123 PyObject *swig_obj[1] ;
52124
52125 if (!args) SWIG_fail;
52126 swig_obj[0] = args;
52127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52128 if (!SWIG_IsOK(res1)) {
52129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52130 }
52131 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52132 {
52133 PyThreadState* __tstate = wxPyBeginAllowThreads();
52134 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52135 wxPyEndAllowThreads(__tstate);
52136 if (PyErr_Occurred()) SWIG_fail;
52137 }
52138 resultobj = SWIG_From_int(static_cast< int >(result));
52139 return resultobj;
52140 fail:
52141 return NULL;
52142 }
52143
52144
52145 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52146 PyObject *resultobj = 0;
52147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52148 bool result;
52149 void *argp1 = 0 ;
52150 int res1 = 0 ;
52151 PyObject *swig_obj[1] ;
52152
52153 if (!args) SWIG_fail;
52154 swig_obj[0] = args;
52155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52156 if (!SWIG_IsOK(res1)) {
52157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52158 }
52159 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52160 {
52161 PyThreadState* __tstate = wxPyBeginAllowThreads();
52162 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52163 wxPyEndAllowThreads(__tstate);
52164 if (PyErr_Occurred()) SWIG_fail;
52165 }
52166 {
52167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52168 }
52169 return resultobj;
52170 fail:
52171 return NULL;
52172 }
52173
52174
52175 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52176 PyObject *resultobj = 0;
52177 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52178 bool arg2 ;
52179 void *argp1 = 0 ;
52180 int res1 = 0 ;
52181 bool val2 ;
52182 int ecode2 = 0 ;
52183 PyObject * obj0 = 0 ;
52184 PyObject * obj1 = 0 ;
52185 char * kwnames[] = {
52186 (char *) "self",(char *) "d", NULL
52187 };
52188
52189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52191 if (!SWIG_IsOK(res1)) {
52192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52193 }
52194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52195 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52196 if (!SWIG_IsOK(ecode2)) {
52197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52198 }
52199 arg2 = static_cast< bool >(val2);
52200 {
52201 PyThreadState* __tstate = wxPyBeginAllowThreads();
52202 (arg1)->SetDone(arg2);
52203 wxPyEndAllowThreads(__tstate);
52204 if (PyErr_Occurred()) SWIG_fail;
52205 }
52206 resultobj = SWIG_Py_Void();
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52214 PyObject *resultobj = 0;
52215 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52216 wxRelationship result;
52217 void *argp1 = 0 ;
52218 int res1 = 0 ;
52219 PyObject *swig_obj[1] ;
52220
52221 if (!args) SWIG_fail;
52222 swig_obj[0] = args;
52223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52224 if (!SWIG_IsOK(res1)) {
52225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52226 }
52227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 result = (wxRelationship)(arg1)->GetRelationship();
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 resultobj = SWIG_From_int(static_cast< int >(result));
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52242 PyObject *resultobj = 0;
52243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52244 wxRelationship arg2 ;
52245 void *argp1 = 0 ;
52246 int res1 = 0 ;
52247 int val2 ;
52248 int ecode2 = 0 ;
52249 PyObject * obj0 = 0 ;
52250 PyObject * obj1 = 0 ;
52251 char * kwnames[] = {
52252 (char *) "self",(char *) "r", NULL
52253 };
52254
52255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52257 if (!SWIG_IsOK(res1)) {
52258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52259 }
52260 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52261 ecode2 = SWIG_AsVal_int(obj1, &val2);
52262 if (!SWIG_IsOK(ecode2)) {
52263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52264 }
52265 arg2 = static_cast< wxRelationship >(val2);
52266 {
52267 PyThreadState* __tstate = wxPyBeginAllowThreads();
52268 (arg1)->SetRelationship(arg2);
52269 wxPyEndAllowThreads(__tstate);
52270 if (PyErr_Occurred()) SWIG_fail;
52271 }
52272 resultobj = SWIG_Py_Void();
52273 return resultobj;
52274 fail:
52275 return NULL;
52276 }
52277
52278
52279 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52280 PyObject *resultobj = 0;
52281 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52282 wxWindow *arg2 = (wxWindow *) 0 ;
52283 bool result;
52284 void *argp1 = 0 ;
52285 int res1 = 0 ;
52286 void *argp2 = 0 ;
52287 int res2 = 0 ;
52288 PyObject * obj0 = 0 ;
52289 PyObject * obj1 = 0 ;
52290 char * kwnames[] = {
52291 (char *) "self",(char *) "otherW", NULL
52292 };
52293
52294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52296 if (!SWIG_IsOK(res1)) {
52297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52298 }
52299 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52301 if (!SWIG_IsOK(res2)) {
52302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52303 }
52304 arg2 = reinterpret_cast< wxWindow * >(argp2);
52305 {
52306 PyThreadState* __tstate = wxPyBeginAllowThreads();
52307 result = (bool)(arg1)->ResetIfWin(arg2);
52308 wxPyEndAllowThreads(__tstate);
52309 if (PyErr_Occurred()) SWIG_fail;
52310 }
52311 {
52312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52313 }
52314 return resultobj;
52315 fail:
52316 return NULL;
52317 }
52318
52319
52320 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52321 PyObject *resultobj = 0;
52322 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52323 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52324 wxWindow *arg3 = (wxWindow *) 0 ;
52325 bool result;
52326 void *argp1 = 0 ;
52327 int res1 = 0 ;
52328 void *argp2 = 0 ;
52329 int res2 = 0 ;
52330 void *argp3 = 0 ;
52331 int res3 = 0 ;
52332 PyObject * obj0 = 0 ;
52333 PyObject * obj1 = 0 ;
52334 PyObject * obj2 = 0 ;
52335 char * kwnames[] = {
52336 (char *) "self",(char *) "constraints",(char *) "win", NULL
52337 };
52338
52339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52341 if (!SWIG_IsOK(res1)) {
52342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52343 }
52344 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52346 if (!SWIG_IsOK(res2)) {
52347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52348 }
52349 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52350 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52351 if (!SWIG_IsOK(res3)) {
52352 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52353 }
52354 arg3 = reinterpret_cast< wxWindow * >(argp3);
52355 {
52356 PyThreadState* __tstate = wxPyBeginAllowThreads();
52357 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52358 wxPyEndAllowThreads(__tstate);
52359 if (PyErr_Occurred()) SWIG_fail;
52360 }
52361 {
52362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52363 }
52364 return resultobj;
52365 fail:
52366 return NULL;
52367 }
52368
52369
52370 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52371 PyObject *resultobj = 0;
52372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52373 wxEdge arg2 ;
52374 wxWindow *arg3 = (wxWindow *) 0 ;
52375 wxWindow *arg4 = (wxWindow *) 0 ;
52376 int result;
52377 void *argp1 = 0 ;
52378 int res1 = 0 ;
52379 int val2 ;
52380 int ecode2 = 0 ;
52381 void *argp3 = 0 ;
52382 int res3 = 0 ;
52383 void *argp4 = 0 ;
52384 int res4 = 0 ;
52385 PyObject * obj0 = 0 ;
52386 PyObject * obj1 = 0 ;
52387 PyObject * obj2 = 0 ;
52388 PyObject * obj3 = 0 ;
52389 char * kwnames[] = {
52390 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52391 };
52392
52393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52395 if (!SWIG_IsOK(res1)) {
52396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52397 }
52398 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52399 ecode2 = SWIG_AsVal_int(obj1, &val2);
52400 if (!SWIG_IsOK(ecode2)) {
52401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52402 }
52403 arg2 = static_cast< wxEdge >(val2);
52404 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52405 if (!SWIG_IsOK(res3)) {
52406 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52407 }
52408 arg3 = reinterpret_cast< wxWindow * >(argp3);
52409 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52410 if (!SWIG_IsOK(res4)) {
52411 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52412 }
52413 arg4 = reinterpret_cast< wxWindow * >(argp4);
52414 {
52415 PyThreadState* __tstate = wxPyBeginAllowThreads();
52416 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52417 wxPyEndAllowThreads(__tstate);
52418 if (PyErr_Occurred()) SWIG_fail;
52419 }
52420 resultobj = SWIG_From_int(static_cast< int >(result));
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52428 PyObject *obj;
52429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52430 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52431 return SWIG_Py_Void();
52432 }
52433
52434 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52435 PyObject *resultobj = 0;
52436 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52437 wxIndividualLayoutConstraint *result = 0 ;
52438 void *argp1 = 0 ;
52439 int res1 = 0 ;
52440 PyObject *swig_obj[1] ;
52441
52442 if (!args) SWIG_fail;
52443 swig_obj[0] = args;
52444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52445 if (!SWIG_IsOK(res1)) {
52446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52447 }
52448 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52449 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52451 return resultobj;
52452 fail:
52453 return NULL;
52454 }
52455
52456
52457 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52458 PyObject *resultobj = 0;
52459 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52460 wxIndividualLayoutConstraint *result = 0 ;
52461 void *argp1 = 0 ;
52462 int res1 = 0 ;
52463 PyObject *swig_obj[1] ;
52464
52465 if (!args) SWIG_fail;
52466 swig_obj[0] = args;
52467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52468 if (!SWIG_IsOK(res1)) {
52469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52470 }
52471 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52472 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52474 return resultobj;
52475 fail:
52476 return NULL;
52477 }
52478
52479
52480 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52481 PyObject *resultobj = 0;
52482 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52483 wxIndividualLayoutConstraint *result = 0 ;
52484 void *argp1 = 0 ;
52485 int res1 = 0 ;
52486 PyObject *swig_obj[1] ;
52487
52488 if (!args) SWIG_fail;
52489 swig_obj[0] = args;
52490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52491 if (!SWIG_IsOK(res1)) {
52492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52493 }
52494 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52495 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52497 return resultobj;
52498 fail:
52499 return NULL;
52500 }
52501
52502
52503 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52504 PyObject *resultobj = 0;
52505 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52506 wxIndividualLayoutConstraint *result = 0 ;
52507 void *argp1 = 0 ;
52508 int res1 = 0 ;
52509 PyObject *swig_obj[1] ;
52510
52511 if (!args) SWIG_fail;
52512 swig_obj[0] = args;
52513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52514 if (!SWIG_IsOK(res1)) {
52515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52516 }
52517 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52518 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52520 return resultobj;
52521 fail:
52522 return NULL;
52523 }
52524
52525
52526 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52527 PyObject *resultobj = 0;
52528 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52529 wxIndividualLayoutConstraint *result = 0 ;
52530 void *argp1 = 0 ;
52531 int res1 = 0 ;
52532 PyObject *swig_obj[1] ;
52533
52534 if (!args) SWIG_fail;
52535 swig_obj[0] = args;
52536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52537 if (!SWIG_IsOK(res1)) {
52538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52539 }
52540 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52541 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52543 return resultobj;
52544 fail:
52545 return NULL;
52546 }
52547
52548
52549 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52550 PyObject *resultobj = 0;
52551 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52552 wxIndividualLayoutConstraint *result = 0 ;
52553 void *argp1 = 0 ;
52554 int res1 = 0 ;
52555 PyObject *swig_obj[1] ;
52556
52557 if (!args) SWIG_fail;
52558 swig_obj[0] = args;
52559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52560 if (!SWIG_IsOK(res1)) {
52561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52562 }
52563 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52564 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52573 PyObject *resultobj = 0;
52574 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52575 wxIndividualLayoutConstraint *result = 0 ;
52576 void *argp1 = 0 ;
52577 int res1 = 0 ;
52578 PyObject *swig_obj[1] ;
52579
52580 if (!args) SWIG_fail;
52581 swig_obj[0] = args;
52582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52583 if (!SWIG_IsOK(res1)) {
52584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52585 }
52586 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52587 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52589 return resultobj;
52590 fail:
52591 return NULL;
52592 }
52593
52594
52595 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52596 PyObject *resultobj = 0;
52597 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52598 wxIndividualLayoutConstraint *result = 0 ;
52599 void *argp1 = 0 ;
52600 int res1 = 0 ;
52601 PyObject *swig_obj[1] ;
52602
52603 if (!args) SWIG_fail;
52604 swig_obj[0] = args;
52605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52606 if (!SWIG_IsOK(res1)) {
52607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52608 }
52609 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52610 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52612 return resultobj;
52613 fail:
52614 return NULL;
52615 }
52616
52617
52618 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52619 PyObject *resultobj = 0;
52620 wxLayoutConstraints *result = 0 ;
52621
52622 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52623 {
52624 PyThreadState* __tstate = wxPyBeginAllowThreads();
52625 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52626 wxPyEndAllowThreads(__tstate);
52627 if (PyErr_Occurred()) SWIG_fail;
52628 }
52629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52630 return resultobj;
52631 fail:
52632 return NULL;
52633 }
52634
52635
52636 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52637 PyObject *resultobj = 0;
52638 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52639 void *argp1 = 0 ;
52640 int res1 = 0 ;
52641 PyObject *swig_obj[1] ;
52642
52643 if (!args) SWIG_fail;
52644 swig_obj[0] = args;
52645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52646 if (!SWIG_IsOK(res1)) {
52647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52648 }
52649 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52650 {
52651 PyThreadState* __tstate = wxPyBeginAllowThreads();
52652 delete arg1;
52653
52654 wxPyEndAllowThreads(__tstate);
52655 if (PyErr_Occurred()) SWIG_fail;
52656 }
52657 resultobj = SWIG_Py_Void();
52658 return resultobj;
52659 fail:
52660 return NULL;
52661 }
52662
52663
52664 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52665 PyObject *resultobj = 0;
52666 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52667 wxWindow *arg2 = (wxWindow *) 0 ;
52668 int *arg3 = (int *) 0 ;
52669 bool result;
52670 void *argp1 = 0 ;
52671 int res1 = 0 ;
52672 void *argp2 = 0 ;
52673 int res2 = 0 ;
52674 int temp3 ;
52675 int res3 = SWIG_TMPOBJ ;
52676 PyObject * obj0 = 0 ;
52677 PyObject * obj1 = 0 ;
52678 char * kwnames[] = {
52679 (char *) "self",(char *) "win", NULL
52680 };
52681
52682 arg3 = &temp3;
52683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52685 if (!SWIG_IsOK(res1)) {
52686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52687 }
52688 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52690 if (!SWIG_IsOK(res2)) {
52691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52692 }
52693 arg2 = reinterpret_cast< wxWindow * >(argp2);
52694 {
52695 PyThreadState* __tstate = wxPyBeginAllowThreads();
52696 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52697 wxPyEndAllowThreads(__tstate);
52698 if (PyErr_Occurred()) SWIG_fail;
52699 }
52700 {
52701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52702 }
52703 if (SWIG_IsTmpObj(res3)) {
52704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52705 } else {
52706 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52708 }
52709 return resultobj;
52710 fail:
52711 return NULL;
52712 }
52713
52714
52715 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52716 PyObject *resultobj = 0;
52717 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52718 bool result;
52719 void *argp1 = 0 ;
52720 int res1 = 0 ;
52721 PyObject *swig_obj[1] ;
52722
52723 if (!args) SWIG_fail;
52724 swig_obj[0] = args;
52725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52726 if (!SWIG_IsOK(res1)) {
52727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52728 }
52729 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52730 {
52731 PyThreadState* __tstate = wxPyBeginAllowThreads();
52732 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52733 wxPyEndAllowThreads(__tstate);
52734 if (PyErr_Occurred()) SWIG_fail;
52735 }
52736 {
52737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52738 }
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52746 PyObject *obj;
52747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52748 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52749 return SWIG_Py_Void();
52750 }
52751
52752 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52753 return SWIG_Python_InitShadowInstance(args);
52754 }
52755
52756 static PyMethodDef SwigMethods[] = {
52757 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52758 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52759 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52760 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52761 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52762 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52763 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52764 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52765 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52767 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52777 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52778 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52779 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52781 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52782 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52783 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52784 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52785 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52786 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52787 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52789 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52795 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52796 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52797 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52798 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52799 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52800 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52801 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52803 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52811 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52812 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52813 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52818 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52819 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52821 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52823 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52825 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52827 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52829 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52831 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52832 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52834 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52836 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52837 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52838 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52839 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52858 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52859 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52860 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52861 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52862 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52863 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52864 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52865 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52867 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52868 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52869 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52870 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52874 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52875 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52876 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52877 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52884 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52891 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52892 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52893 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52894 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52896 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52897 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52898 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52900 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52901 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52902 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52903 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52908 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52909 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52910 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52911 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52912 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52913 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52916 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52917 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52918 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52920 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52921 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52923 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52924 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52925 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52926 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52927 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52928 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52929 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52930 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52931 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52932 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52933 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52936 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52937 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52938 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52941 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52944 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52945 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52946 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52947 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52949 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52952 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52954 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52957 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52958 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52959 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52962 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52963 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52964 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52968 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52969 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52970 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52974 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52979 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52980 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52981 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52982 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52983 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52984 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52985 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52989 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52992 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52993 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52995 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52996 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52997 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53003 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53004 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53006 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53007 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53008 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53009 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53010 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53011 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53012 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53013 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53015 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53016 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53017 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53018 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53019 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53020 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53021 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53022 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53024 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53033 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53040 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53045 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53046 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53061 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53062 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53063 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53064 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53065 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53067 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53069 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53071 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53073 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53075 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53078 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53079 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53080 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53081 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53083 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53100 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53101 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53107 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53108 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53109 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53110 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53111 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53112 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53113 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53114 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53115 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53116 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53117 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53118 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53119 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53120 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53121 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53122 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53123 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53124 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53125 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53126 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53127 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53128 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53129 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53130 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53131 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53132 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53133 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53134 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53135 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53136 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53137 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53138 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53139 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53140 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53141 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53143 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53144 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53145 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53146 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53149 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53153 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53157 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53158 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53159 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53160 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53162 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53163 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53165 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53167 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53169 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53171 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53172 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53173 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53175 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53176 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53178 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53179 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53182 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53183 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53186 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53188 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53189 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53190 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53192 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53194 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53195 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53197 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53198 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53201 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53202 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53203 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53204 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53205 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53207 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53208 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53210 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53211 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53212 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53214 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53215 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53216 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53218 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53219 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53221 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53227 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53228 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53229 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53230 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53231 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53232 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53233 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53234 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53235 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53236 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53237 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53238 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53239 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53240 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53241 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53242 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53243 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53244 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53245 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53246 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53247 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53248 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53249 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53250 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53252 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53253 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53254 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53255 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53256 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53257 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53258 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53259 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53260 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53261 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53262 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53263 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53264 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53265 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53266 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53267 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53268 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53269 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53270 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53271 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53272 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53273 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53274 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53275 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53276 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53277 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53278 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53279 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53280 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53281 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53282 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53283 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53285 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53286 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53288 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53289 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53290 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53291 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53293 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53294 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53295 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53296 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53297 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53298 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53299 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53300 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53301 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53303 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53304 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53305 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53306 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53307 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53308 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53309 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53310 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53311 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53312 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53313 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53314 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53315 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53316 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53317 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53318 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53319 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53320 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53321 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53322 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53323 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53324 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53325 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53326 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53327 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53328 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53329 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53330 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53332 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53333 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53336 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53337 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53338 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53339 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53340 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53341 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53343 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53344 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53347 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53348 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53350 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53351 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53353 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53354 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53356 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53357 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53358 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53360 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53362 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53365 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53366 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53367 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53369 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53370 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53371 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53373 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53374 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53376 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53377 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53378 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53379 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53380 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53383 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53385 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53387 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53388 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53389 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53392 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53393 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53394 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53396 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53397 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53398 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53400 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53401 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53402 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53403 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53404 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53405 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53407 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53408 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53409 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53410 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53411 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53412 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53413 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53414 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53420 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53422 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53424 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53425 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53427 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53428 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53429 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53431 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53432 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53433 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53434 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53435 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53436 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53439 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53440 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53441 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53444 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53447 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53448 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53450 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53452 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53455 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53457 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53458 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53460 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53461 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53464 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53465 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53466 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53468 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53470 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53471 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53472 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53474 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53476 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53478 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53479 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53481 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53482 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53484 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53486 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53487 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53488 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53490 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53492 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53493 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53494 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53496 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53498 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53499 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53500 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53501 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53503 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53505 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53507 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53509 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53510 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53512 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53513 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53514 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53515 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53516 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53517 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53518 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53519 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53521 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53523 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53525 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53527 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53529 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53531 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53532 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53533 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53534 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53535 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53536 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53542 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53543 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53544 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53545 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53546 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53547 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53548 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53550 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53551 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53552 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53553 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53555 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53556 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53557 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53558 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53560 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53561 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53562 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53563 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53565 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53566 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53568 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53569 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53570 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53572 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53574 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53575 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53576 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53577 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53578 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53580 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53581 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53582 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53583 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53585 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53586 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53587 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53588 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53589 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53590 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53591 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53592 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53593 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53594 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53596 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53599 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53600 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53601 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53603 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53605 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53607 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53609 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53610 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53620 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53621 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53625 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53626 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53627 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53628 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53629 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53630 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53631 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53632 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53633 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53634 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53635 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53636 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53637 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53638 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53639 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53641 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53642 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53645 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53646 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53651 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53652 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53655 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53656 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53657 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53658 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53661 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53662 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53663 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53665 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53667 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53668 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53669 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53671 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53673 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53675 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53678 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53679 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53680 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53681 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53682 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53683 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53684 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_GetTmpDefaultItem", (PyCFunction)_wrap_Window_GetTmpDefaultItem, METH_O, NULL},
53687 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53691 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53692 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53693 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53694 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53701 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53707 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53708 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53709 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53710 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53711 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53713 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53723 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53724 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53725 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53726 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53729 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53730 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53731 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53732 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53734 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53735 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53739 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53745 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53746 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53747 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53748 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53750 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53751 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53753 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53756 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53758 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53759 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53760 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53769 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53773 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53775 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53785 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53786 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53787 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53788 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53792 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53795 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53797 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53800 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53802 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53803 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53806 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53808 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53809 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53810 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53811 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53812 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53817 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53818 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53819 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53821 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53822 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53823 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53825 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53827 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53828 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53829 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53831 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53832 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53835 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53843 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53850 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53858 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53861 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53862 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53875 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53877 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53879 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53880 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53882 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53884 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53885 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53887 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53888 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53889 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53893 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53912 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53913 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53915 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53917 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53918 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53919 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53921 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53922 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53925 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53926 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53928 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53929 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53931 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53934 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53935 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53937 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53939 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53941 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53942 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53944 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53945 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53948 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53950 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53952 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53954 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53957 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53959 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53960 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53961 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53963 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53964 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53965 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53967 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53970 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53972 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53973 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53977 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53981 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53982 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53984 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53988 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53990 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53992 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53993 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53994 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53995 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53999 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54000 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54001 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54002 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54004 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54005 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54010 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54011 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54012 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54013 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54014 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54016 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54018 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54020 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54021 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54023 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54025 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54028 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54029 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54030 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54032 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54033 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54034 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54048 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54049 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54050 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54051 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54052 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54053 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54059 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54060 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54064 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54065 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54067 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54068 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54070 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54072 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54073 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54075 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54076 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54077 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54083 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54084 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54085 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54086 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54087 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54088 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54095 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54097 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54098 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54099 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54100 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54101 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54102 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54104 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54108 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54109 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54110 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54111 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54112 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54113 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54114 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54116 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54117 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54118 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54124 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54125 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54126 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54128 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54129 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54130 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54136 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54137 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54138 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54139 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54140 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54144 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54145 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54150 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54151 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54153 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54154 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54159 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54161 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54162 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54163 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54164 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54165 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54170 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54171 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54176 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54180 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54181 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54182 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54183 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54186 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54188 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54189 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54190 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54191 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54193 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54198 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54199 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54200 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54201 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54202 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54203 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54204 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54205 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54206 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54207 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54208 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54210 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54211 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54212 { NULL, NULL, 0, NULL }
54213 };
54214
54215
54216 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54217
54218 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54219 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54220 }
54221 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54222 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54223 }
54224 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54225 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54226 }
54227 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54228 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54229 }
54230 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54231 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54232 }
54233 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54234 return (void *)((wxSizer *) ((wxGridSizer *) x));
54235 }
54236 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54237 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54238 }
54239 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54240 return (void *)((wxSizer *) ((wxPySizer *) x));
54241 }
54242 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54243 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54244 }
54245 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54246 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54247 }
54248 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54249 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54250 }
54251 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54252 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54253 }
54254 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54255 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54256 }
54257 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54258 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54259 }
54260 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54261 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54262 }
54263 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54264 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54265 }
54266 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54267 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54268 }
54269 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54271 }
54272 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54274 }
54275 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54276 return (void *)((wxEvent *) ((wxPyEvent *) x));
54277 }
54278 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54279 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54280 }
54281 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54282 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54283 }
54284 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54285 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54286 }
54287 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54288 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54289 }
54290 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54291 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54292 }
54293 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54294 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54295 }
54296 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54297 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54298 }
54299 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54300 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54301 }
54302 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54303 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54304 }
54305 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54306 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54307 }
54308 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54309 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54310 }
54311 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54312 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54313 }
54314 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54315 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54316 }
54317 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54318 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54319 }
54320 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54321 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54322 }
54323 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54325 }
54326 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54328 }
54329 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54330 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54331 }
54332 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54333 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54334 }
54335 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54336 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54337 }
54338 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54339 return (void *)((wxEvent *) ((wxShowEvent *) x));
54340 }
54341 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54342 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54343 }
54344 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54346 }
54347 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54348 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54349 }
54350 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54352 }
54353 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54355 }
54356 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54358 }
54359 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54360 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54361 }
54362 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54363 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54364 }
54365 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54366 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54367 }
54368 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54369 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54370 }
54371 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54372 return (void *)((wxControl *) ((wxControlWithItems *) x));
54373 }
54374 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54375 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54376 }
54377 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54378 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54379 }
54380 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54381 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54382 }
54383 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54384 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54385 }
54386 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54387 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54388 }
54389 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54390 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54391 }
54392 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54393 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54394 }
54395 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54396 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54397 }
54398 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54399 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54400 }
54401 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54402 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54403 }
54404 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54405 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54406 }
54407 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54408 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54409 }
54410 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54411 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54412 }
54413 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54414 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54415 }
54416 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54417 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54418 }
54419 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54420 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54421 }
54422 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54423 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54424 }
54425 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54426 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54427 }
54428 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54429 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54430 }
54431 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54432 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54433 }
54434 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54435 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54436 }
54437 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54438 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54439 }
54440 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54441 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54442 }
54443 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54444 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54445 }
54446 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54447 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54448 }
54449 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54450 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54451 }
54452 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54453 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54454 }
54455 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54456 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54457 }
54458 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54459 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54460 }
54461 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54462 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54463 }
54464 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54465 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54466 }
54467 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54468 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54469 }
54470 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54471 return (void *)((wxObject *) ((wxSizerItem *) x));
54472 }
54473 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54474 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54475 }
54476 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54477 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54478 }
54479 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54480 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54481 }
54482 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54483 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54484 }
54485 static void *_p_wxSizerTo_p_wxObject(void *x) {
54486 return (void *)((wxObject *) ((wxSizer *) x));
54487 }
54488 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54489 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54490 }
54491 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54492 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54493 }
54494 static void *_p_wxEventTo_p_wxObject(void *x) {
54495 return (void *)((wxObject *) ((wxEvent *) x));
54496 }
54497 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54498 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54499 }
54500 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54501 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54502 }
54503 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54504 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54505 }
54506 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54507 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54508 }
54509 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54510 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54511 }
54512 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54513 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54514 }
54515 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54516 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54517 }
54518 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54519 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54520 }
54521 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54522 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54523 }
54524 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54525 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54526 }
54527 static void *_p_wxControlTo_p_wxObject(void *x) {
54528 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54529 }
54530 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54531 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54532 }
54533 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54534 return (void *)((wxObject *) ((wxFSFile *) x));
54535 }
54536 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54537 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54538 }
54539 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54540 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54541 }
54542 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54544 }
54545 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54547 }
54548 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) ((wxMenuItem *) x));
54550 }
54551 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54553 }
54554 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54556 }
54557 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54559 }
54560 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54562 }
54563 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54565 }
54566 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54568 }
54569 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54571 }
54572 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54574 }
54575 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54577 }
54578 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54580 }
54581 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54583 }
54584 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54586 }
54587 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54589 }
54590 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54592 }
54593 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54595 }
54596 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54598 }
54599 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54601 }
54602 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54604 }
54605 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54607 }
54608 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) ((wxImageHandler *) x));
54610 }
54611 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54613 }
54614 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54616 }
54617 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) ((wxEvtHandler *) x));
54619 }
54620 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54622 }
54623 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54625 }
54626 static void *_p_wxImageTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) ((wxImage *) x));
54628 }
54629 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54631 }
54632 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54634 }
54635 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54637 }
54638 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54640 }
54641 static void *_p_wxWindowTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54643 }
54644 static void *_p_wxMenuTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54646 }
54647 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54649 }
54650 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) ((wxFileSystem *) x));
54652 }
54653 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54655 }
54656 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54658 }
54659 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54661 }
54662 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54664 }
54665 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54667 }
54668 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54670 }
54671 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54673 }
54674 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54676 }
54677 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54679 }
54680 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54682 }
54683 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54685 }
54686 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54688 }
54689 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54691 }
54692 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54694 }
54695 static void *_p_wxControlTo_p_wxWindow(void *x) {
54696 return (void *)((wxWindow *) ((wxControl *) x));
54697 }
54698 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54699 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54700 }
54701 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54702 return (void *)((wxWindow *) ((wxMenuBar *) x));
54703 }
54704 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54705 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54706 }
54707 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54708 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54709 }
54710 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54711 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54712 }
54713 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54714 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54715 }
54716 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54717 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54718 }
54719 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54720 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54721 }
54722 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54723 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54724 }
54725 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54726 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54727 }
54728 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54729 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54730 }
54731 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54732 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54733 }
54734 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54735 return (void *)((wxValidator *) ((wxPyValidator *) x));
54736 }
54737 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54738 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54739 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};
54740 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54741 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54742 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54743 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54744 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54745 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54746 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54747 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54748 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54749 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54750 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54751 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54752 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54753 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54754 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54755 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54756 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54757 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54758 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54759 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54760 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54761 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54762 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54763 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54764 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54765 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54766 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54767 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54768 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54769 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54770 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54771 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54772 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54773 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54774 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54775 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54776 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54777 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54778 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54779 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54780 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54781 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54782 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54783 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54784 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54785 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54786 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54787 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54788 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54789 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54790 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54792 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54793 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54868
54869 static swig_type_info *swig_type_initial[] = {
54870 &_swigt__p_buffer,
54871 &_swigt__p_char,
54872 &_swigt__p_form_ops_t,
54873 &_swigt__p_int,
54874 &_swigt__p_long,
54875 &_swigt__p_unsigned_char,
54876 &_swigt__p_unsigned_int,
54877 &_swigt__p_unsigned_long,
54878 &_swigt__p_wxANIHandler,
54879 &_swigt__p_wxAcceleratorEntry,
54880 &_swigt__p_wxAcceleratorTable,
54881 &_swigt__p_wxActivateEvent,
54882 &_swigt__p_wxAppTraits,
54883 &_swigt__p_wxArrayString,
54884 &_swigt__p_wxBMPHandler,
54885 &_swigt__p_wxBitmap,
54886 &_swigt__p_wxBoxSizer,
54887 &_swigt__p_wxButton,
54888 &_swigt__p_wxCURHandler,
54889 &_swigt__p_wxCaret,
54890 &_swigt__p_wxChildFocusEvent,
54891 &_swigt__p_wxClipboardTextEvent,
54892 &_swigt__p_wxCloseEvent,
54893 &_swigt__p_wxColour,
54894 &_swigt__p_wxCommandEvent,
54895 &_swigt__p_wxContextMenuEvent,
54896 &_swigt__p_wxControl,
54897 &_swigt__p_wxControlWithItems,
54898 &_swigt__p_wxCursor,
54899 &_swigt__p_wxDC,
54900 &_swigt__p_wxDateEvent,
54901 &_swigt__p_wxDateTime,
54902 &_swigt__p_wxDisplayChangedEvent,
54903 &_swigt__p_wxDropFilesEvent,
54904 &_swigt__p_wxDuplexMode,
54905 &_swigt__p_wxEraseEvent,
54906 &_swigt__p_wxEvent,
54907 &_swigt__p_wxEventLoop,
54908 &_swigt__p_wxEventLoopActivator,
54909 &_swigt__p_wxEvtHandler,
54910 &_swigt__p_wxFSFile,
54911 &_swigt__p_wxFileSystem,
54912 &_swigt__p_wxFileSystemHandler,
54913 &_swigt__p_wxFlexGridSizer,
54914 &_swigt__p_wxFocusEvent,
54915 &_swigt__p_wxFont,
54916 &_swigt__p_wxFrame,
54917 &_swigt__p_wxGBPosition,
54918 &_swigt__p_wxGBSizerItem,
54919 &_swigt__p_wxGBSpan,
54920 &_swigt__p_wxGIFHandler,
54921 &_swigt__p_wxGridBagSizer,
54922 &_swigt__p_wxGridSizer,
54923 &_swigt__p_wxHelpEvent__Origin,
54924 &_swigt__p_wxICOHandler,
54925 &_swigt__p_wxIconizeEvent,
54926 &_swigt__p_wxIdleEvent,
54927 &_swigt__p_wxImage,
54928 &_swigt__p_wxImageHandler,
54929 &_swigt__p_wxImageHistogram,
54930 &_swigt__p_wxImage_HSVValue,
54931 &_swigt__p_wxImage_RGBValue,
54932 &_swigt__p_wxIndividualLayoutConstraint,
54933 &_swigt__p_wxInitDialogEvent,
54934 &_swigt__p_wxInputStream,
54935 &_swigt__p_wxInternetFSHandler,
54936 &_swigt__p_wxItemContainer,
54937 &_swigt__p_wxJPEGHandler,
54938 &_swigt__p_wxKeyEvent,
54939 &_swigt__p_wxLayoutConstraints,
54940 &_swigt__p_wxMaximizeEvent,
54941 &_swigt__p_wxMemoryFSHandler,
54942 &_swigt__p_wxMenu,
54943 &_swigt__p_wxMenuBar,
54944 &_swigt__p_wxMenuBarBase,
54945 &_swigt__p_wxMenuEvent,
54946 &_swigt__p_wxMenuItem,
54947 &_swigt__p_wxMouseCaptureChangedEvent,
54948 &_swigt__p_wxMouseEvent,
54949 &_swigt__p_wxMoveEvent,
54950 &_swigt__p_wxNavigationKeyEvent,
54951 &_swigt__p_wxNcPaintEvent,
54952 &_swigt__p_wxNotifyEvent,
54953 &_swigt__p_wxObject,
54954 &_swigt__p_wxOutputStream,
54955 &_swigt__p_wxPCXHandler,
54956 &_swigt__p_wxPNGHandler,
54957 &_swigt__p_wxPNMHandler,
54958 &_swigt__p_wxPaintEvent,
54959 &_swigt__p_wxPaletteChangedEvent,
54960 &_swigt__p_wxPaperSize,
54961 &_swigt__p_wxPoint,
54962 &_swigt__p_wxPoint2D,
54963 &_swigt__p_wxPropagateOnce,
54964 &_swigt__p_wxPropagationDisabler,
54965 &_swigt__p_wxPyApp,
54966 &_swigt__p_wxPyCommandEvent,
54967 &_swigt__p_wxPyDropTarget,
54968 &_swigt__p_wxPyEvent,
54969 &_swigt__p_wxPyFileSystemHandler,
54970 &_swigt__p_wxPyImageHandler,
54971 &_swigt__p_wxPyInputStream,
54972 &_swigt__p_wxPySizer,
54973 &_swigt__p_wxPyValidator,
54974 &_swigt__p_wxQuantize,
54975 &_swigt__p_wxQueryNewPaletteEvent,
54976 &_swigt__p_wxRealPoint,
54977 &_swigt__p_wxRect,
54978 &_swigt__p_wxRegion,
54979 &_swigt__p_wxScrollEvent,
54980 &_swigt__p_wxScrollWinEvent,
54981 &_swigt__p_wxSetCursorEvent,
54982 &_swigt__p_wxShowEvent,
54983 &_swigt__p_wxSize,
54984 &_swigt__p_wxSizeEvent,
54985 &_swigt__p_wxSizer,
54986 &_swigt__p_wxSizerItem,
54987 &_swigt__p_wxStaticBox,
54988 &_swigt__p_wxStaticBoxSizer,
54989 &_swigt__p_wxStdDialogButtonSizer,
54990 &_swigt__p_wxSysColourChangedEvent,
54991 &_swigt__p_wxTIFFHandler,
54992 &_swigt__p_wxToolTip,
54993 &_swigt__p_wxUpdateUIEvent,
54994 &_swigt__p_wxValidator,
54995 &_swigt__p_wxVisualAttributes,
54996 &_swigt__p_wxWindow,
54997 &_swigt__p_wxWindowCreateEvent,
54998 &_swigt__p_wxWindowDestroyEvent,
54999 &_swigt__p_wxXPMHandler,
55000 &_swigt__p_wxZipFSHandler,
55001 };
55002
55003 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55004 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55005 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55006 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55007 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55008 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55009 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55010 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55011 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55012 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55013 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55014 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55015 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55016 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55017 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}};
55018 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55019 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}};
55020 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55021 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}};
55022 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55023 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55024 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55025 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55026 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55027 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}};
55028 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55029 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}};
55030 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55031 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55032 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55033 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55034 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55035 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55036 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55037 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55038 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55039 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
55040 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55041 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55042 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}};
55043 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55044 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55045 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}};
55046 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}};
55047 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55048 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55049 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55050 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55051 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55052 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55053 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55054 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55055 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}};
55056 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55057 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}};
55058 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55061 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}};
55062 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55069 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}};
55070 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55072 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55073 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55074 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55075 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55076 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55077 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55082 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55083 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55085 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55100 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55101 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55102 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55110 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55111 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55112 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55113 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55118 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}};
55119 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}};
55120 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55125 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55127 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}};
55128 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55129 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}};
55130 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55134
55135 static swig_cast_info *swig_cast_initial[] = {
55136 _swigc__p_buffer,
55137 _swigc__p_char,
55138 _swigc__p_form_ops_t,
55139 _swigc__p_int,
55140 _swigc__p_long,
55141 _swigc__p_unsigned_char,
55142 _swigc__p_unsigned_int,
55143 _swigc__p_unsigned_long,
55144 _swigc__p_wxANIHandler,
55145 _swigc__p_wxAcceleratorEntry,
55146 _swigc__p_wxAcceleratorTable,
55147 _swigc__p_wxActivateEvent,
55148 _swigc__p_wxAppTraits,
55149 _swigc__p_wxArrayString,
55150 _swigc__p_wxBMPHandler,
55151 _swigc__p_wxBitmap,
55152 _swigc__p_wxBoxSizer,
55153 _swigc__p_wxButton,
55154 _swigc__p_wxCURHandler,
55155 _swigc__p_wxCaret,
55156 _swigc__p_wxChildFocusEvent,
55157 _swigc__p_wxClipboardTextEvent,
55158 _swigc__p_wxCloseEvent,
55159 _swigc__p_wxColour,
55160 _swigc__p_wxCommandEvent,
55161 _swigc__p_wxContextMenuEvent,
55162 _swigc__p_wxControl,
55163 _swigc__p_wxControlWithItems,
55164 _swigc__p_wxCursor,
55165 _swigc__p_wxDC,
55166 _swigc__p_wxDateEvent,
55167 _swigc__p_wxDateTime,
55168 _swigc__p_wxDisplayChangedEvent,
55169 _swigc__p_wxDropFilesEvent,
55170 _swigc__p_wxDuplexMode,
55171 _swigc__p_wxEraseEvent,
55172 _swigc__p_wxEvent,
55173 _swigc__p_wxEventLoop,
55174 _swigc__p_wxEventLoopActivator,
55175 _swigc__p_wxEvtHandler,
55176 _swigc__p_wxFSFile,
55177 _swigc__p_wxFileSystem,
55178 _swigc__p_wxFileSystemHandler,
55179 _swigc__p_wxFlexGridSizer,
55180 _swigc__p_wxFocusEvent,
55181 _swigc__p_wxFont,
55182 _swigc__p_wxFrame,
55183 _swigc__p_wxGBPosition,
55184 _swigc__p_wxGBSizerItem,
55185 _swigc__p_wxGBSpan,
55186 _swigc__p_wxGIFHandler,
55187 _swigc__p_wxGridBagSizer,
55188 _swigc__p_wxGridSizer,
55189 _swigc__p_wxHelpEvent__Origin,
55190 _swigc__p_wxICOHandler,
55191 _swigc__p_wxIconizeEvent,
55192 _swigc__p_wxIdleEvent,
55193 _swigc__p_wxImage,
55194 _swigc__p_wxImageHandler,
55195 _swigc__p_wxImageHistogram,
55196 _swigc__p_wxImage_HSVValue,
55197 _swigc__p_wxImage_RGBValue,
55198 _swigc__p_wxIndividualLayoutConstraint,
55199 _swigc__p_wxInitDialogEvent,
55200 _swigc__p_wxInputStream,
55201 _swigc__p_wxInternetFSHandler,
55202 _swigc__p_wxItemContainer,
55203 _swigc__p_wxJPEGHandler,
55204 _swigc__p_wxKeyEvent,
55205 _swigc__p_wxLayoutConstraints,
55206 _swigc__p_wxMaximizeEvent,
55207 _swigc__p_wxMemoryFSHandler,
55208 _swigc__p_wxMenu,
55209 _swigc__p_wxMenuBar,
55210 _swigc__p_wxMenuBarBase,
55211 _swigc__p_wxMenuEvent,
55212 _swigc__p_wxMenuItem,
55213 _swigc__p_wxMouseCaptureChangedEvent,
55214 _swigc__p_wxMouseEvent,
55215 _swigc__p_wxMoveEvent,
55216 _swigc__p_wxNavigationKeyEvent,
55217 _swigc__p_wxNcPaintEvent,
55218 _swigc__p_wxNotifyEvent,
55219 _swigc__p_wxObject,
55220 _swigc__p_wxOutputStream,
55221 _swigc__p_wxPCXHandler,
55222 _swigc__p_wxPNGHandler,
55223 _swigc__p_wxPNMHandler,
55224 _swigc__p_wxPaintEvent,
55225 _swigc__p_wxPaletteChangedEvent,
55226 _swigc__p_wxPaperSize,
55227 _swigc__p_wxPoint,
55228 _swigc__p_wxPoint2D,
55229 _swigc__p_wxPropagateOnce,
55230 _swigc__p_wxPropagationDisabler,
55231 _swigc__p_wxPyApp,
55232 _swigc__p_wxPyCommandEvent,
55233 _swigc__p_wxPyDropTarget,
55234 _swigc__p_wxPyEvent,
55235 _swigc__p_wxPyFileSystemHandler,
55236 _swigc__p_wxPyImageHandler,
55237 _swigc__p_wxPyInputStream,
55238 _swigc__p_wxPySizer,
55239 _swigc__p_wxPyValidator,
55240 _swigc__p_wxQuantize,
55241 _swigc__p_wxQueryNewPaletteEvent,
55242 _swigc__p_wxRealPoint,
55243 _swigc__p_wxRect,
55244 _swigc__p_wxRegion,
55245 _swigc__p_wxScrollEvent,
55246 _swigc__p_wxScrollWinEvent,
55247 _swigc__p_wxSetCursorEvent,
55248 _swigc__p_wxShowEvent,
55249 _swigc__p_wxSize,
55250 _swigc__p_wxSizeEvent,
55251 _swigc__p_wxSizer,
55252 _swigc__p_wxSizerItem,
55253 _swigc__p_wxStaticBox,
55254 _swigc__p_wxStaticBoxSizer,
55255 _swigc__p_wxStdDialogButtonSizer,
55256 _swigc__p_wxSysColourChangedEvent,
55257 _swigc__p_wxTIFFHandler,
55258 _swigc__p_wxToolTip,
55259 _swigc__p_wxUpdateUIEvent,
55260 _swigc__p_wxValidator,
55261 _swigc__p_wxVisualAttributes,
55262 _swigc__p_wxWindow,
55263 _swigc__p_wxWindowCreateEvent,
55264 _swigc__p_wxWindowDestroyEvent,
55265 _swigc__p_wxXPMHandler,
55266 _swigc__p_wxZipFSHandler,
55267 };
55268
55269
55270 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55271
55272 static swig_const_info swig_const_table[] = {
55273 {0, 0, 0, 0.0, 0, 0}};
55274
55275 #ifdef __cplusplus
55276 }
55277 #endif
55278 /* -----------------------------------------------------------------------------
55279 * Type initialization:
55280 * This problem is tough by the requirement that no dynamic
55281 * memory is used. Also, since swig_type_info structures store pointers to
55282 * swig_cast_info structures and swig_cast_info structures store pointers back
55283 * to swig_type_info structures, we need some lookup code at initialization.
55284 * The idea is that swig generates all the structures that are needed.
55285 * The runtime then collects these partially filled structures.
55286 * The SWIG_InitializeModule function takes these initial arrays out of
55287 * swig_module, and does all the lookup, filling in the swig_module.types
55288 * array with the correct data and linking the correct swig_cast_info
55289 * structures together.
55290 *
55291 * The generated swig_type_info structures are assigned staticly to an initial
55292 * array. We just loop though that array, and handle each type individually.
55293 * First we lookup if this type has been already loaded, and if so, use the
55294 * loaded structure instead of the generated one. Then we have to fill in the
55295 * cast linked list. The cast data is initially stored in something like a
55296 * two-dimensional array. Each row corresponds to a type (there are the same
55297 * number of rows as there are in the swig_type_initial array). Each entry in
55298 * a column is one of the swig_cast_info structures for that type.
55299 * The cast_initial array is actually an array of arrays, because each row has
55300 * a variable number of columns. So to actually build the cast linked list,
55301 * we find the array of casts associated with the type, and loop through it
55302 * adding the casts to the list. The one last trick we need to do is making
55303 * sure the type pointer in the swig_cast_info struct is correct.
55304 *
55305 * First off, we lookup the cast->type name to see if it is already loaded.
55306 * There are three cases to handle:
55307 * 1) If the cast->type has already been loaded AND the type we are adding
55308 * casting info to has not been loaded (it is in this module), THEN we
55309 * replace the cast->type pointer with the type pointer that has already
55310 * been loaded.
55311 * 2) If BOTH types (the one we are adding casting info to, and the
55312 * cast->type) are loaded, THEN the cast info has already been loaded by
55313 * the previous module so we just ignore it.
55314 * 3) Finally, if cast->type has not already been loaded, then we add that
55315 * swig_cast_info to the linked list (because the cast->type) pointer will
55316 * be correct.
55317 * ----------------------------------------------------------------------------- */
55318
55319 #ifdef __cplusplus
55320 extern "C" {
55321 #if 0
55322 } /* c-mode */
55323 #endif
55324 #endif
55325
55326 #if 0
55327 #define SWIGRUNTIME_DEBUG
55328 #endif
55329
55330 SWIGRUNTIME void
55331 SWIG_InitializeModule(void *clientdata) {
55332 size_t i;
55333 swig_module_info *module_head;
55334 static int init_run = 0;
55335
55336 clientdata = clientdata;
55337
55338 if (init_run) return;
55339 init_run = 1;
55340
55341 /* Initialize the swig_module */
55342 swig_module.type_initial = swig_type_initial;
55343 swig_module.cast_initial = swig_cast_initial;
55344
55345 /* Try and load any already created modules */
55346 module_head = SWIG_GetModule(clientdata);
55347 if (module_head) {
55348 swig_module.next = module_head->next;
55349 module_head->next = &swig_module;
55350 } else {
55351 /* This is the first module loaded */
55352 swig_module.next = &swig_module;
55353 SWIG_SetModule(clientdata, &swig_module);
55354 }
55355
55356 /* Now work on filling in swig_module.types */
55357 #ifdef SWIGRUNTIME_DEBUG
55358 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55359 #endif
55360 for (i = 0; i < swig_module.size; ++i) {
55361 swig_type_info *type = 0;
55362 swig_type_info *ret;
55363 swig_cast_info *cast;
55364
55365 #ifdef SWIGRUNTIME_DEBUG
55366 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55367 #endif
55368
55369 /* if there is another module already loaded */
55370 if (swig_module.next != &swig_module) {
55371 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55372 }
55373 if (type) {
55374 /* Overwrite clientdata field */
55375 #ifdef SWIGRUNTIME_DEBUG
55376 printf("SWIG_InitializeModule: found type %s\n", type->name);
55377 #endif
55378 if (swig_module.type_initial[i]->clientdata) {
55379 type->clientdata = swig_module.type_initial[i]->clientdata;
55380 #ifdef SWIGRUNTIME_DEBUG
55381 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55382 #endif
55383 }
55384 } else {
55385 type = swig_module.type_initial[i];
55386 }
55387
55388 /* Insert casting types */
55389 cast = swig_module.cast_initial[i];
55390 while (cast->type) {
55391 /* Don't need to add information already in the list */
55392 ret = 0;
55393 #ifdef SWIGRUNTIME_DEBUG
55394 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55395 #endif
55396 if (swig_module.next != &swig_module) {
55397 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55398 #ifdef SWIGRUNTIME_DEBUG
55399 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55400 #endif
55401 }
55402 if (ret) {
55403 if (type == swig_module.type_initial[i]) {
55404 #ifdef SWIGRUNTIME_DEBUG
55405 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55406 #endif
55407 cast->type = ret;
55408 ret = 0;
55409 } else {
55410 /* Check for casting already in the list */
55411 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55412 #ifdef SWIGRUNTIME_DEBUG
55413 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55414 #endif
55415 if (!ocast) ret = 0;
55416 }
55417 }
55418
55419 if (!ret) {
55420 #ifdef SWIGRUNTIME_DEBUG
55421 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55422 #endif
55423 if (type->cast) {
55424 type->cast->prev = cast;
55425 cast->next = type->cast;
55426 }
55427 type->cast = cast;
55428 }
55429 cast++;
55430 }
55431 /* Set entry in modules->types array equal to the type */
55432 swig_module.types[i] = type;
55433 }
55434 swig_module.types[i] = 0;
55435
55436 #ifdef SWIGRUNTIME_DEBUG
55437 printf("**** SWIG_InitializeModule: Cast List ******\n");
55438 for (i = 0; i < swig_module.size; ++i) {
55439 int j = 0;
55440 swig_cast_info *cast = swig_module.cast_initial[i];
55441 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55442 while (cast->type) {
55443 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55444 cast++;
55445 ++j;
55446 }
55447 printf("---- Total casts: %d\n",j);
55448 }
55449 printf("**** SWIG_InitializeModule: Cast List ******\n");
55450 #endif
55451 }
55452
55453 /* This function will propagate the clientdata field of type to
55454 * any new swig_type_info structures that have been added into the list
55455 * of equivalent types. It is like calling
55456 * SWIG_TypeClientData(type, clientdata) a second time.
55457 */
55458 SWIGRUNTIME void
55459 SWIG_PropagateClientData(void) {
55460 size_t i;
55461 swig_cast_info *equiv;
55462 static int init_run = 0;
55463
55464 if (init_run) return;
55465 init_run = 1;
55466
55467 for (i = 0; i < swig_module.size; i++) {
55468 if (swig_module.types[i]->clientdata) {
55469 equiv = swig_module.types[i]->cast;
55470 while (equiv) {
55471 if (!equiv->converter) {
55472 if (equiv->type && !equiv->type->clientdata)
55473 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55474 }
55475 equiv = equiv->next;
55476 }
55477 }
55478 }
55479 }
55480
55481 #ifdef __cplusplus
55482 #if 0
55483 {
55484 /* c-mode */
55485 #endif
55486 }
55487 #endif
55488
55489
55490
55491 #ifdef __cplusplus
55492 extern "C" {
55493 #endif
55494
55495 /* Python-specific SWIG API */
55496 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55497 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55498 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55499
55500 /* -----------------------------------------------------------------------------
55501 * global variable support code.
55502 * ----------------------------------------------------------------------------- */
55503
55504 typedef struct swig_globalvar {
55505 char *name; /* Name of global variable */
55506 PyObject *(*get_attr)(void); /* Return the current value */
55507 int (*set_attr)(PyObject *); /* Set the value */
55508 struct swig_globalvar *next;
55509 } swig_globalvar;
55510
55511 typedef struct swig_varlinkobject {
55512 PyObject_HEAD
55513 swig_globalvar *vars;
55514 } swig_varlinkobject;
55515
55516 SWIGINTERN PyObject *
55517 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55518 return PyString_FromString("<Swig global variables>");
55519 }
55520
55521 SWIGINTERN PyObject *
55522 swig_varlink_str(swig_varlinkobject *v) {
55523 PyObject *str = PyString_FromString("(");
55524 swig_globalvar *var;
55525 for (var = v->vars; var; var=var->next) {
55526 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55527 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55528 }
55529 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55530 return str;
55531 }
55532
55533 SWIGINTERN int
55534 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55535 PyObject *str = swig_varlink_str(v);
55536 fprintf(fp,"Swig global variables ");
55537 fprintf(fp,"%s\n", PyString_AsString(str));
55538 Py_DECREF(str);
55539 return 0;
55540 }
55541
55542 SWIGINTERN void
55543 swig_varlink_dealloc(swig_varlinkobject *v) {
55544 swig_globalvar *var = v->vars;
55545 while (var) {
55546 swig_globalvar *n = var->next;
55547 free(var->name);
55548 free(var);
55549 var = n;
55550 }
55551 }
55552
55553 SWIGINTERN PyObject *
55554 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55555 PyObject *res = NULL;
55556 swig_globalvar *var = v->vars;
55557 while (var) {
55558 if (strcmp(var->name,n) == 0) {
55559 res = (*var->get_attr)();
55560 break;
55561 }
55562 var = var->next;
55563 }
55564 if (res == NULL && !PyErr_Occurred()) {
55565 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55566 }
55567 return res;
55568 }
55569
55570 SWIGINTERN int
55571 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55572 int res = 1;
55573 swig_globalvar *var = v->vars;
55574 while (var) {
55575 if (strcmp(var->name,n) == 0) {
55576 res = (*var->set_attr)(p);
55577 break;
55578 }
55579 var = var->next;
55580 }
55581 if (res == 1 && !PyErr_Occurred()) {
55582 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55583 }
55584 return res;
55585 }
55586
55587 SWIGINTERN PyTypeObject*
55588 swig_varlink_type(void) {
55589 static char varlink__doc__[] = "Swig var link object";
55590 static PyTypeObject varlink_type;
55591 static int type_init = 0;
55592 if (!type_init) {
55593 const PyTypeObject tmp
55594 = {
55595 PyObject_HEAD_INIT(NULL)
55596 0, /* Number of items in variable part (ob_size) */
55597 (char *)"swigvarlink", /* Type name (tp_name) */
55598 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55599 0, /* Itemsize (tp_itemsize) */
55600 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55601 (printfunc) swig_varlink_print, /* Print (tp_print) */
55602 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55603 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55604 0, /* tp_compare */
55605 (reprfunc) swig_varlink_repr, /* tp_repr */
55606 0, /* tp_as_number */
55607 0, /* tp_as_sequence */
55608 0, /* tp_as_mapping */
55609 0, /* tp_hash */
55610 0, /* tp_call */
55611 (reprfunc)swig_varlink_str, /* tp_str */
55612 0, /* tp_getattro */
55613 0, /* tp_setattro */
55614 0, /* tp_as_buffer */
55615 0, /* tp_flags */
55616 varlink__doc__, /* tp_doc */
55617 0, /* tp_traverse */
55618 0, /* tp_clear */
55619 0, /* tp_richcompare */
55620 0, /* tp_weaklistoffset */
55621 #if PY_VERSION_HEX >= 0x02020000
55622 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55623 #endif
55624 #if PY_VERSION_HEX >= 0x02030000
55625 0, /* tp_del */
55626 #endif
55627 #ifdef COUNT_ALLOCS
55628 0,0,0,0 /* tp_alloc -> tp_next */
55629 #endif
55630 };
55631 varlink_type = tmp;
55632 varlink_type.ob_type = &PyType_Type;
55633 type_init = 1;
55634 }
55635 return &varlink_type;
55636 }
55637
55638 /* Create a variable linking object for use later */
55639 SWIGINTERN PyObject *
55640 SWIG_Python_newvarlink(void) {
55641 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55642 if (result) {
55643 result->vars = 0;
55644 }
55645 return ((PyObject*) result);
55646 }
55647
55648 SWIGINTERN void
55649 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55650 swig_varlinkobject *v = (swig_varlinkobject *) p;
55651 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55652 if (gv) {
55653 size_t size = strlen(name)+1;
55654 gv->name = (char *)malloc(size);
55655 if (gv->name) {
55656 strncpy(gv->name,name,size);
55657 gv->get_attr = get_attr;
55658 gv->set_attr = set_attr;
55659 gv->next = v->vars;
55660 }
55661 }
55662 v->vars = gv;
55663 }
55664
55665 SWIGINTERN PyObject *
55666 SWIG_globals() {
55667 static PyObject *_SWIG_globals = 0;
55668 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55669 return _SWIG_globals;
55670 }
55671
55672 /* -----------------------------------------------------------------------------
55673 * constants/methods manipulation
55674 * ----------------------------------------------------------------------------- */
55675
55676 /* Install Constants */
55677 SWIGINTERN void
55678 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55679 PyObject *obj = 0;
55680 size_t i;
55681 for (i = 0; constants[i].type; ++i) {
55682 switch(constants[i].type) {
55683 case SWIG_PY_POINTER:
55684 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55685 break;
55686 case SWIG_PY_BINARY:
55687 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55688 break;
55689 default:
55690 obj = 0;
55691 break;
55692 }
55693 if (obj) {
55694 PyDict_SetItemString(d, constants[i].name, obj);
55695 Py_DECREF(obj);
55696 }
55697 }
55698 }
55699
55700 /* -----------------------------------------------------------------------------*/
55701 /* Fix SwigMethods to carry the callback ptrs when needed */
55702 /* -----------------------------------------------------------------------------*/
55703
55704 SWIGINTERN void
55705 SWIG_Python_FixMethods(PyMethodDef *methods,
55706 swig_const_info *const_table,
55707 swig_type_info **types,
55708 swig_type_info **types_initial) {
55709 size_t i;
55710 for (i = 0; methods[i].ml_name; ++i) {
55711 const char *c = methods[i].ml_doc;
55712 if (c && (c = strstr(c, "swig_ptr: "))) {
55713 int j;
55714 swig_const_info *ci = 0;
55715 const char *name = c + 10;
55716 for (j = 0; const_table[j].type; ++j) {
55717 if (strncmp(const_table[j].name, name,
55718 strlen(const_table[j].name)) == 0) {
55719 ci = &(const_table[j]);
55720 break;
55721 }
55722 }
55723 if (ci) {
55724 size_t shift = (ci->ptype) - types;
55725 swig_type_info *ty = types_initial[shift];
55726 size_t ldoc = (c - methods[i].ml_doc);
55727 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55728 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55729 if (ndoc) {
55730 char *buff = ndoc;
55731 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55732 if (ptr) {
55733 strncpy(buff, methods[i].ml_doc, ldoc);
55734 buff += ldoc;
55735 strncpy(buff, "swig_ptr: ", 10);
55736 buff += 10;
55737 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55738 methods[i].ml_doc = ndoc;
55739 }
55740 }
55741 }
55742 }
55743 }
55744 }
55745
55746 #ifdef __cplusplus
55747 }
55748 #endif
55749
55750 /* -----------------------------------------------------------------------------*
55751 * Partial Init method
55752 * -----------------------------------------------------------------------------*/
55753
55754 #ifdef __cplusplus
55755 extern "C"
55756 #endif
55757 SWIGEXPORT void SWIG_init(void) {
55758 PyObject *m, *d;
55759
55760 /* Fix SwigMethods to carry the callback ptrs when needed */
55761 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55762
55763 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55764 d = PyModule_GetDict(m);
55765
55766 SWIG_InitializeModule(0);
55767 SWIG_InstallConstants(d,swig_const_table);
55768
55769
55770
55771 #ifndef wxPyUSE_EXPORT
55772 // Make our API structure a CObject so other modules can import it
55773 // from this module.
55774 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55775 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55776 Py_XDECREF(cobj);
55777 #endif
55778
55779 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55780 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55781 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55782 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55783 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55784 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55785 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55786 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55787 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55788 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55789 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55790 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55791 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55792 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55793 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55794 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55795 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55796 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55797 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55798 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55799 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55800 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55801 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55802 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55803 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55804 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55805 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55806 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55807 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55808 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55809 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55810 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55811 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55812 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55813 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55814 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55815 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55816 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55817 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55818 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55819 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55820 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55821 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55822 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55823 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55824 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55825 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55826 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55827 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55828 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55829 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55830 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55831 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55832 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55833 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55834 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55835 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55836 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55837 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55838 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55839 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55840 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55841 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55842 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55843 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55844 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55845 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55846 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55847 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55848 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55849 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55850 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55851 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55852 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55853 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55854 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55855 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55856 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55857 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55858 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55859 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55860 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55861 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55862 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55863 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55864 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55865 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55866 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55867 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55868 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55869 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55870 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55871 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55872 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55873 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55874 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55875 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55876 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55877 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55878 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55879 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55880 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55881 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55882 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55883 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55884 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55885 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55886 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55887 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55888 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55889 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55890 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55891 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55892 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55893 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55894 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55895 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55896 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55897 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55898 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55899 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55900 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55901 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55902 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55903 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55904 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55905 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55906 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55907 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55908 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55909 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55910 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55911 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55912 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55913 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55914 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55915 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55916 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55917 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55918 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55919 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55920 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55921 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55922 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55923 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55924 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55925 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55926 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55927 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55928 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55929 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55930 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55931 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55932 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55933 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55934 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55935 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55936 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55937 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55938 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55939 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55940 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55941 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55942 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55943 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55944 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55945 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55946 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55947 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55948 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55949 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55950 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55951 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55952 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55953 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55954 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55955 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55956 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55957 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55958 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55959 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55960 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55961 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55962 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55963 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55964 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55965 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55966 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55967 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55968 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55969 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55970 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55971 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55972 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55973 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55974 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55975 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55976 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55977 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55978 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55979 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55980 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55981 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55982 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55983 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55984 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55985 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55986 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55987 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55988 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55989 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55990 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55991 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55992 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55993 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55994 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55995 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55996 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55997 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55998 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55999 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56000 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56001 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56002 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56003 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56004 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56005 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56006 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56007 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56008 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56009 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56010 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56011 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56012 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56013 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56014 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56015 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56016 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56017 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56018 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56019 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56020 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56021 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56022 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56023 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56024 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56025 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56026 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56027 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56028 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56029 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56030 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56031 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56032 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56033 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56034 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56035 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56036 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56037 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56038 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56039 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56040 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56041 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56042 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56043 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56044 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56045 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56046 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56047 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56048 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56049 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56050 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56051 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56052 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56053 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56054 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56055 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56056 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56057 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56058 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56059 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56060 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56061 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56062 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56063 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56064 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56065 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56066 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56067 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56068 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56069 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56070 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56071 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56072 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56073 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56074 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56075 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56076 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56077 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56078 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56079 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56080 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56081 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56082 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56083 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56084 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56085 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56086 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56087 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56088 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56089 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56090 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56091 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56092 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56093 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56094 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56095 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56096 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56097 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56098 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56099 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56100 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56101 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56102 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56103 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56104 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56105 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56106 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56107 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56108 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56109 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56110 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56111 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56112 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56113 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56114 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56115 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56116 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56117 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56118 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56119 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56120 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56121 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56122 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56123 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56124 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56125 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56126 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56127 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56128 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56129 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56130 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56131 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56132 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56133 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56134 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56135 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56136 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56137 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56138 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56139 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56140 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56141 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56142 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56143 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56144 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56145 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56146 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56147 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56148 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56149 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56150 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56151 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56152 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56153 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56154 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56155 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56156 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56157 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56158 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56159 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56160 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56161 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56162 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56163 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56164 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56165 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56166 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56167 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56168 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56169 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56170 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56171 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56172 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56173 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56174 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56175 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56176 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56177 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56178 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56179 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56185 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56186 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56187 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56188 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56189 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56203 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56204 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56205 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56206 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56207 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56208 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56209 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56210 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56211 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56212 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56213 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56214 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56215 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56216 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56217 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56218 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56219 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56220 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56221 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56222 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56223 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56224 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56225 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56226 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56227 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56228 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56229 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56230 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56231 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56232 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56233 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56234 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56235 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56236 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56237 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56238 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56239 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56240 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56241 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56242 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56243 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56244 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56245 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56246 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56247 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56248 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56249 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56250 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56251 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56252 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56253 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56254 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56255 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56256 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56257 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56258 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56259 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56260 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56261 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56262 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56263 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56264 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56265 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56266 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56267 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56268 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56269 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56270 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56271 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56272 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56273 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56274 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56275 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56276 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56277 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56278 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56279 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56280 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56281 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56282 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56283 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56284 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56285 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56286 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56287 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56288 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56289 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56290 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56291 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56292 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56293 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56294 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56295 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56296 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56297 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56298 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56299 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56300 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56301 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56302 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56303 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56304 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56305 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56306 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56307 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56308 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56309 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56310 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56311 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56312 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56313 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56314 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56315 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56316 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56317 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56318 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56319 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56320 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56321 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56322 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56323 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56324 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56325 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56326 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56327 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56328 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56329 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56330 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56331 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56332 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56333 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56334 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56335 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56336 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56337 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56338 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56339 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56340 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56341 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56342 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56343 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56344 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56345 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56346 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56347 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56348 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56349 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56350 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56351 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56352 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56353 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56354 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56355 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56356 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56357 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56358 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56359 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56360 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56361 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56362 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56363 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56364 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56365 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56366 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56367 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56368 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56369 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56370 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56371 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56372 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56373 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56374 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56375 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56376 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56377 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56378 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56379 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56380 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56381 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56382 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56383 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56384 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56385 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56388 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56389 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56390 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56391 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56392 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56393 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56394 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56395 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56402 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56403 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56404 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56405 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56406 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56407 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56408 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56409 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56410 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56411 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56412 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56413 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56414 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56415 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56416 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56417 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56418 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56419 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56420 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56421 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56422 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56423 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56424 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56425 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56426 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56427 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56428 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56429 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56430 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56431 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56432 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56433 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56434 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56435 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56436 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56437 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56438 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56439 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56440 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56441 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56442
56443 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56444
56445
56446 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56447
56448 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56449 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56450 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56451 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56453 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56454 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56457 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56458 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56459 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56460 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56461 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56462 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56465 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56466 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56467 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56468 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56469 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56470 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56471 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56472 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56473 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56474 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56475 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56476 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56477 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56478 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56479 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56480 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56481 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56482 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56483 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56484 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56485 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56486 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56487 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56488 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56489 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56490 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56491 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56492 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56493 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56494 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56495 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56496 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56497 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56498 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56499 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56500 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56501 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56502 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56503 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56504 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56505 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56506 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56507 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56508 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56509 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56510 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56511 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56512 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56513 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56514 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56515 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56516 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56517 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56518 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56519 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56520 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56521 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56522 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56523 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56524 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56525 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56526 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56527 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56528 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56529 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56530 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56531 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56532 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56533 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56534 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56535 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56536 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56537 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56538 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56539 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56540 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56541 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56542 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56543 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56544 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56545 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56546 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56547 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56548 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56549 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56550 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56551 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56552 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56553 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56554 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56555 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56556 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56557 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56558 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56559 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56560 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56561 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56562 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56563 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56564 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56565 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56566 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56567 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56568 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56569 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56570 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56571 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56572 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56573 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56574 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56575 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56576 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56577 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56578 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56579 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56580 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56581 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56582 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56583 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56584 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56585 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56586 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56587 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56588 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56589 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56590 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56591 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56592 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56593 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56594 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56595 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56596 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56597 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56598 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56599 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56600 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56601 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56602 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56603 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56604 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56605 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56606 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56607 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56608 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56609 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56610 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56611 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56612 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56613 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56614 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56615 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56616 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56617 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56618 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56619 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56620 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56621 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56622 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56623 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56624 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56625 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56626 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56627 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56628 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56629 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56630 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56631 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56632 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56633 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56634 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56635 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56636 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56637 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56638 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56639 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56640 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56641 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56642 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56643 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56644 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56645 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56646 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56647 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56648 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56649 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56650 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56651 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56652 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56653 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56654
56655 // Initialize threading, some globals and such
56656 __wxPyPreStart(d);
56657
56658
56659 // Although these are defined in __version__ they need to be here too so
56660 // that an assert can be done to ensure that the wxPython and the wxWindows
56661 // versions match.
56662 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56663 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56664 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56665
56666 }
56667
wxWidgets (Impactor)