]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Use correct DLL import/export specifier for multi-lib builds
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692 #include "wx/wxPython/twoitem.h"
2693
2694
2695 #ifndef wxPyUSE_EXPORT
2696 // Helper functions for dealing with SWIG objects and such. These are
2697 // located here so they know about the SWIG types and functions declared
2698 // in the wrapper code.
2699
2700 #include <wx/hashmap.h>
2701 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2702
2703
2704 // Maintains a hashmap of className to swig_type_info pointers. Given the
2705 // name of a class either looks up the type info in the cache, or scans the
2706 // SWIG tables for it.
2707 extern PyObject* wxPyPtrTypeMap;
2708 static
2709 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2710
2711 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2712
2713 if (typeInfoCache == NULL)
2714 typeInfoCache = new wxPyTypeInfoHashMap;
2715
2716 wxString name(className);
2717 swig_type_info* swigType = (*typeInfoCache)[name];
2718
2719 if (! swigType) {
2720 // it wasn't in the cache, so look it up from SWIG
2721 name.Append(wxT(" *"));
2722 swigType = SWIG_TypeQuery(name.mb_str());
2723
2724 // if it still wasn't found, try looking for a mapped name
2725 if (!swigType) {
2726 PyObject* item;
2727 name = className;
2728
2729 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2730 (char*)(const char*)name.mbc_str())) != NULL) {
2731 name = wxString(PyString_AsString(item), *wxConvCurrent);
2732 name.Append(wxT(" *"));
2733 swigType = SWIG_TypeQuery(name.mb_str());
2734 }
2735 }
2736 if (swigType) {
2737 // and add it to the map if found
2738 (*typeInfoCache)[className] = swigType;
2739 }
2740 }
2741 return swigType;
2742 }
2743
2744
2745 // Check if a class name is a type known to SWIG
2746 bool wxPyCheckSwigType(const wxChar* className) {
2747
2748 swig_type_info* swigType = wxPyFindSwigType(className);
2749 return swigType != NULL;
2750 }
2751
2752
2753 // Given a pointer to a C++ object and a class name, construct a Python proxy
2754 // object for it.
2755 PyObject* wxPyConstructObject(void* ptr,
2756 const wxChar* className,
2757 int setThisOwn) {
2758
2759 swig_type_info* swigType = wxPyFindSwigType(className);
2760 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2761
2762 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2763 }
2764
2765
2766 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2767 // Ensures that the proxy object is of the specified (or derived) type. If
2768 // not able to perform the conversion then a Python exception is set and the
2769 // error should be handled properly in the caller. Returns True on success.
2770 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2771 const wxChar* className) {
2772
2773 swig_type_info* swigType = wxPyFindSwigType(className);
2774 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2775
2776 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2777 }
2778
2779
2780
2781 // Make a SWIGified pointer object suitable for a .this attribute
2782 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2783
2784 PyObject* robj = NULL;
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2788
2789 robj = PySwigObject_New(ptr, swigType, 0);
2790 return robj;
2791 }
2792
2793
2794 // Python's PyInstance_Check does not return True for instances of new-style
2795 // classes. This should get close enough for both new and old classes but I
2796 // should re-evaluate the need for doing instance checks...
2797 bool wxPyInstance_Check(PyObject* obj) {
2798 return PyObject_HasAttrString(obj, "__class__") != 0;
2799 }
2800
2801
2802 // This one checks if the object is an instance of a SWIG proxy class (it has
2803 // a .this attribute, and the .this attribute is a PySwigObject.)
2804 bool wxPySwigInstance_Check(PyObject* obj) {
2805 static PyObject* this_str = NULL;
2806 if (this_str == NULL)
2807 this_str = PyString_FromString("this");
2808
2809 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2810 if (this_attr) {
2811 bool retval = (PySwigObject_Check(this_attr) != 0);
2812 Py_DECREF(this_attr);
2813 return retval;
2814 }
2815
2816 PyErr_Clear();
2817 return false;
2818 }
2819
2820
2821 // Export a C API in a struct. Other modules will be able to load this from
2822 // the wx._core_ module and will then have safe access to these functions,
2823 // even if they are located in another shared library.
2824 static wxPyCoreAPI API = {
2825
2826 wxPyCheckSwigType,
2827 wxPyConstructObject,
2828 wxPyConvertSwigPtr,
2829 wxPyMakeSwigPtr,
2830
2831 wxPyBeginAllowThreads,
2832 wxPyEndAllowThreads,
2833 wxPyBeginBlockThreads,
2834 wxPyEndBlockThreads,
2835
2836 wxPy_ConvertList,
2837
2838 wxString_in_helper,
2839 Py2wxString,
2840 wx2PyString,
2841
2842 byte_LIST_helper,
2843 int_LIST_helper,
2844 long_LIST_helper,
2845 string_LIST_helper,
2846 wxPoint_LIST_helper,
2847 wxBitmap_LIST_helper,
2848 wxString_LIST_helper,
2849 wxAcceleratorEntry_LIST_helper,
2850
2851 wxSize_helper,
2852 wxPoint_helper,
2853 wxRealPoint_helper,
2854 wxRect_helper,
2855 wxColour_helper,
2856 wxPoint2D_helper,
2857
2858 wxPySimple_typecheck,
2859 wxColour_typecheck,
2860
2861 wxPyCBH_setCallbackInfo,
2862 wxPyCBH_findCallback,
2863 wxPyCBH_callCallback,
2864 wxPyCBH_callCallbackObj,
2865 wxPyCBH_delete,
2866
2867 wxPyMake_wxObject,
2868 wxPyMake_wxSizer,
2869 wxPyPtrTypeMap_Add,
2870 wxPy2int_seq_helper,
2871 wxPy4int_seq_helper,
2872 wxArrayString2PyList_helper,
2873 wxArrayInt2PyList_helper,
2874
2875 wxPyClientData_dtor,
2876 wxPyUserData_dtor,
2877 wxPyOORClientData_dtor,
2878
2879 wxPyCBInputStream_create,
2880 wxPyCBInputStream_copy,
2881
2882 wxPyInstance_Check,
2883 wxPySwigInstance_Check,
2884
2885 wxPyCheckForApp
2886
2887 };
2888
2889 #endif
2890
2891
2892 #if !WXWIN_COMPATIBILITY_2_4
2893 #define wxHIDE_READONLY 0
2894 #endif
2895
2896
2897 #define SWIG_From_long PyInt_FromLong
2898
2899
2900 SWIGINTERNINLINE PyObject *
2901 SWIG_From_int (int value)
2902 {
2903 return SWIG_From_long (value);
2904 }
2905
2906 static const wxString wxPyEmptyString(wxEmptyString);
2907 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2908 return self->GetClassInfo()->GetClassName();
2909 }
2910 SWIGINTERN void wxObject_Destroy(wxObject *self){
2911 delete self;
2912 }
2913
2914 #ifndef __WXMAC__
2915 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2916 #endif
2917
2918
2919 #include <limits.h>
2920 #ifndef LLONG_MIN
2921 # define LLONG_MIN LONG_LONG_MIN
2922 #endif
2923 #ifndef LLONG_MAX
2924 # define LLONG_MAX LONG_LONG_MAX
2925 #endif
2926 #ifndef ULLONG_MAX
2927 # define ULLONG_MAX ULONG_LONG_MAX
2928 #endif
2929
2930
2931 SWIGINTERN int
2932 SWIG_AsVal_long (PyObject* obj, long* val)
2933 {
2934 if (PyNumber_Check(obj)) {
2935 if (val) *val = PyInt_AsLong(obj);
2936 return SWIG_OK;
2937 }
2938 return SWIG_TypeError;
2939 }
2940
2941
2942 SWIGINTERN int
2943 SWIG_AsVal_int (PyObject * obj, int *val)
2944 {
2945 long v;
2946 int res = SWIG_AsVal_long (obj, &v);
2947 if (SWIG_IsOK(res)) {
2948 if ((v < INT_MIN || v > INT_MAX)) {
2949 return SWIG_OverflowError;
2950 } else {
2951 if (val) *val = static_cast< int >(v);
2952 }
2953 }
2954 return res;
2955 }
2956
2957 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2958 wxSize temp, *obj = &temp;
2959 if ( other == Py_None ) return false;
2960 if ( ! wxSize_helper(other, &obj) ) {
2961 PyErr_Clear();
2962 return false;
2963 }
2964 return self->operator==(*obj);
2965 }
2966 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return true;
2969 if ( ! wxSize_helper(other, &obj)) {
2970 PyErr_Clear();
2971 return true;
2972 }
2973 return self->operator!=(*obj);
2974 }
2975 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2977 PyObject* tup = PyTuple_New(2);
2978 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2979 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2980 wxPyEndBlockThreads(blocked);
2981 return tup;
2982 }
2983
2984 SWIGINTERN int
2985 SWIG_AsVal_double (PyObject *obj, double* val)
2986 {
2987 if (PyNumber_Check(obj)) {
2988 if (val) *val = PyFloat_AsDouble(obj);
2989 return SWIG_OK;
2990 }
2991 return SWIG_TypeError;
2992 }
2993
2994
2995 #define SWIG_From_double PyFloat_FromDouble
2996
2997 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2998 wxRealPoint temp, *obj = &temp;
2999 if ( other == Py_None ) return false;
3000 if ( ! wxRealPoint_helper(other, &obj) ) {
3001 PyErr_Clear();
3002 return false;
3003 }
3004 return self->operator==(*obj);
3005 }
3006 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3007 wxRealPoint temp, *obj = &temp;
3008 if ( other == Py_None ) return true;
3009 if ( ! wxRealPoint_helper(other, &obj)) {
3010 PyErr_Clear();
3011 return true;
3012 }
3013 return self->operator!=(*obj);
3014 }
3015 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3016 self->x = x;
3017 self->y = y;
3018 }
3019 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3024 wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3028 wxPoint temp, *obj = &temp;
3029 if ( other == Py_None ) return false;
3030 if ( ! wxPoint_helper(other, &obj) ) {
3031 PyErr_Clear();
3032 return false;
3033 }
3034 return self->operator==(*obj);
3035 }
3036 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3037 wxPoint temp, *obj = &temp;
3038 if ( other == Py_None ) return true;
3039 if ( ! wxPoint_helper(other, &obj)) {
3040 PyErr_Clear();
3041 return true;
3042 }
3043 return self->operator!=(*obj);
3044 }
3045 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3046 self->x = x;
3047 self->y = y;
3048 }
3049 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3050 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3051 PyObject* tup = PyTuple_New(2);
3052 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3053 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3054 wxPyEndBlockThreads(blocked);
3055 return tup;
3056 }
3057 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3058 wxRect temp, *obj = &temp;
3059 if ( other == Py_None ) return false;
3060 if ( ! wxRect_helper(other, &obj) ) {
3061 PyErr_Clear();
3062 return false;
3063 }
3064 return self->operator==(*obj);
3065 }
3066 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3067 wxRect temp, *obj = &temp;
3068 if ( other == Py_None ) return true;
3069 if ( ! wxRect_helper(other, &obj)) {
3070 PyErr_Clear();
3071 return true;
3072 }
3073 return self->operator!=(*obj);
3074 }
3075 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3076 self->x = x;
3077 self->y = y;
3078 self->width = width;
3079 self->height = height;
3080 }
3081 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3082 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3083 PyObject* tup = PyTuple_New(4);
3084 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3085 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3086 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3087 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3088 wxPyEndBlockThreads(blocked);
3089 return tup;
3090 }
3091
3092 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3093 wxRegion reg1(*r1);
3094 wxRegion reg2(*r2);
3095 wxRect dest(0,0,0,0);
3096 PyObject* obj;
3097
3098 reg1.Intersect(reg2);
3099 dest = reg1.GetBox();
3100
3101 if (dest != wxRect(0,0,0,0)) {
3102 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3103 wxRect* newRect = new wxRect(dest);
3104 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3105 wxPyEndBlockThreads(blocked);
3106 return obj;
3107 }
3108 Py_INCREF(Py_None);
3109 return Py_None;
3110 }
3111
3112 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3113 wxPoint2D temp, *obj = &temp;
3114 if ( other == Py_None ) return false;
3115 if ( ! wxPoint2D_helper(other, &obj) ) {
3116 PyErr_Clear();
3117 return false;
3118 }
3119 return self->operator==(*obj);
3120 }
3121 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3122 wxPoint2D temp, *obj = &temp;
3123 if ( other == Py_None ) return true;
3124 if ( ! wxPoint2D_helper(other, &obj)) {
3125 PyErr_Clear();
3126 return true;
3127 }
3128 return self->operator!=(*obj);
3129 }
3130 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3131 self->m_x = x;
3132 self->m_y = y;
3133 }
3134 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3135 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 PyObject* tup = PyTuple_New(2);
3137 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3138 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3139 wxPyEndBlockThreads(blocked);
3140 return tup;
3141 }
3142
3143 #include "wx/wxPython/pyistream.h"
3144
3145 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3146 wxInputStream* wxis = wxPyCBInputStream::create(p);
3147 if (wxis)
3148 return new wxPyInputStream(wxis);
3149 else
3150 return NULL;
3151 }
3152
3153 SWIGINTERN swig_type_info*
3154 SWIG_pchar_descriptor()
3155 {
3156 static int init = 0;
3157 static swig_type_info* info = 0;
3158 if (!init) {
3159 info = SWIG_TypeQuery("_p_char");
3160 init = 1;
3161 }
3162 return info;
3163 }
3164
3165
3166 SWIGINTERNINLINE PyObject *
3167 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3168 {
3169 if (carray) {
3170 if (size > INT_MAX) {
3171 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3172 return pchar_descriptor ?
3173 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3174 } else {
3175 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3176 }
3177 } else {
3178 return SWIG_Py_Void();
3179 }
3180 }
3181
3182
3183 SWIGINTERNINLINE PyObject *
3184 SWIG_From_char (char c)
3185 {
3186 return SWIG_FromCharPtrAndSize(&c,1);
3187 }
3188
3189
3190 SWIGINTERNINLINE PyObject*
3191 SWIG_From_unsigned_SS_long (unsigned long value)
3192 {
3193 return (value > LONG_MAX) ?
3194 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3195 }
3196
3197
3198 SWIGINTERNINLINE PyObject *
3199 SWIG_From_size_t (size_t value)
3200 {
3201 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3202 }
3203
3204
3205 SWIGINTERN int
3206 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3207 {
3208 if (PyString_Check(obj)) {
3209 char *cstr; int len;
3210 PyString_AsStringAndSize(obj, &cstr, &len);
3211 if (cptr) {
3212 if (alloc) {
3213 /*
3214 In python the user should not be able to modify the inner
3215 string representation. To warranty that, if you define
3216 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3217 buffer is always returned.
3218
3219 The default behavior is just to return the pointer value,
3220 so, be careful.
3221 */
3222 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3223 if (*alloc != SWIG_OLDOBJ)
3224 #else
3225 if (*alloc == SWIG_NEWOBJ)
3226 #endif
3227 {
3228 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3229 *alloc = SWIG_NEWOBJ;
3230 }
3231 else {
3232 *cptr = cstr;
3233 *alloc = SWIG_OLDOBJ;
3234 }
3235 } else {
3236 *cptr = PyString_AsString(obj);
3237 }
3238 }
3239 if (psize) *psize = len + 1;
3240 return SWIG_OK;
3241 } else {
3242 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3243 if (pchar_descriptor) {
3244 void* vptr = 0;
3245 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3246 if (cptr) *cptr = (char *) vptr;
3247 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3248 if (alloc) *alloc = SWIG_OLDOBJ;
3249 return SWIG_OK;
3250 }
3251 }
3252 }
3253 return SWIG_TypeError;
3254 }
3255
3256
3257 SWIGINTERN int
3258 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3259 {
3260 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3261 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3262 if (SWIG_IsOK(res)) {
3263 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3264 if (csize <= size) {
3265 if (val) {
3266 if (csize) memcpy(val, cptr, csize*sizeof(char));
3267 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3268 }
3269 if (alloc == SWIG_NEWOBJ) {
3270 delete[] cptr;
3271 res = SWIG_DelNewMask(res);
3272 }
3273 return res;
3274 }
3275 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3276 }
3277 return SWIG_TypeError;
3278 }
3279
3280
3281 SWIGINTERN int
3282 SWIG_AsVal_char (PyObject * obj, char *val)
3283 {
3284 int res = SWIG_AsCharArray(obj, val, 1);
3285 if (!SWIG_IsOK(res)) {
3286 long v;
3287 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3288 if (SWIG_IsOK(res)) {
3289 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3290 if (val) *val = static_cast< char >(v);
3291 } else {
3292 res = SWIG_OverflowError;
3293 }
3294 }
3295 }
3296 return res;
3297 }
3298
3299 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3300 // We use only strings for the streams, not unicode
3301 PyObject* str = PyObject_Str(obj);
3302 if (! str) {
3303 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3304 return;
3305 }
3306 self->Write(PyString_AS_STRING(str),
3307 PyString_GET_SIZE(str));
3308 Py_DECREF(str);
3309 }
3310
3311 #include "wx/wxPython/pyistream.h"
3312
3313
3314 class wxPyFileSystemHandler : public wxFileSystemHandler
3315 {
3316 public:
3317 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3318
3319 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3320 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3321 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3322 DEC_PYCALLBACK_STRING__pure(FindNext);
3323
3324 wxString GetProtocol(const wxString& location) {
3325 return wxFileSystemHandler::GetProtocol(location);
3326 }
3327
3328 wxString GetLeftLocation(const wxString& location) {
3329 return wxFileSystemHandler::GetLeftLocation(location);
3330 }
3331
3332 wxString GetAnchor(const wxString& location) {
3333 return wxFileSystemHandler::GetAnchor(location);
3334 }
3335
3336 wxString GetRightLocation(const wxString& location) {
3337 return wxFileSystemHandler::GetRightLocation(location);
3338 }
3339
3340 wxString GetMimeTypeFromExt(const wxString& location) {
3341 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3342 }
3343
3344 PYPRIVATE;
3345 };
3346
3347
3348 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3349 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3350 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3351 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3352
3353
3354 SWIGINTERN int
3355 SWIG_AsVal_bool (PyObject *obj, bool *val)
3356 {
3357 if (obj == Py_True) {
3358 if (val) *val = true;
3359 return SWIG_OK;
3360 } else if (obj == Py_False) {
3361 if (val) *val = false;
3362 return SWIG_OK;
3363 } else {
3364 long v = 0;
3365 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3366 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3367 return res;
3368 }
3369 }
3370
3371 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3372 wxFileName fname = wxFileSystem::URLToFileName(url);
3373 return fname.GetFullPath();
3374 }
3375
3376 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3377 wxImage& image,
3378 long type) {
3379 wxMemoryFSHandler::AddFile(filename, image, type);
3380 }
3381
3382 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3383 const wxBitmap& bitmap,
3384 long type) {
3385 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3386 }
3387
3388 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3389 PyObject* data) {
3390 if (! PyString_Check(data)) {
3391 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3392 "Expected string object"));
3393 return;
3394 }
3395
3396 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3397 void* ptr = (void*)PyString_AsString(data);
3398 size_t size = PyString_Size(data);
3399 wxPyEndBlockThreads(blocked);
3400
3401 wxMemoryFSHandler::AddFile(filename, ptr, size);
3402 }
3403
3404
3405 #include "wx/wxPython/pyistream.h"
3406
3407
3408 SWIGINTERN int
3409 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3410 {
3411 long v = 0;
3412 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3413 return SWIG_TypeError;
3414 }
3415 else if (val)
3416 *val = (unsigned long)v;
3417 return SWIG_OK;
3418 }
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3423 {
3424 unsigned long v;
3425 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3426 if (SWIG_IsOK(res)) {
3427 if ((v > UCHAR_MAX)) {
3428 return SWIG_OverflowError;
3429 } else {
3430 if (val) *val = static_cast< unsigned char >(v);
3431 }
3432 }
3433 return res;
3434 }
3435
3436
3437 SWIGINTERNINLINE PyObject *
3438 SWIG_From_unsigned_SS_char (unsigned char value)
3439 {
3440 return SWIG_From_unsigned_SS_long (value);
3441 }
3442
3443 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3444 wxImageHistogramEntry e = (*self)[key];
3445 return e.value;
3446 }
3447 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3448 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3449 wxImageHistogramEntry e = (*self)[key];
3450 return e.value;
3451 }
3452 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3453 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3454 colour.Green(),
3455 colour.Blue());
3456 wxImageHistogramEntry e = (*self)[key];
3457 return e.value;
3458 }
3459
3460 typedef unsigned char* buffer;
3461
3462
3463 // Pull the nested class out to the top level for SWIG's sake
3464 #define wxImage_RGBValue wxImage::RGBValue
3465 #define wxImage_HSVValue wxImage::HSVValue
3466
3467 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3468 if (width > 0 && height > 0)
3469 return new wxImage(width, height, clear);
3470 else
3471 return new wxImage;
3472 }
3473 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3474 return new wxImage(bitmap.ConvertToImage());
3475 }
3476 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3477 if (DATASIZE != width*height*3) {
3478 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3479 return NULL;
3480 }
3481
3482 // Copy the source data so the wxImage can clean it up later
3483 buffer copy = (buffer)malloc(DATASIZE);
3484 if (copy == NULL) {
3485 wxPyBLOCK_THREADS(PyErr_NoMemory());
3486 return NULL;
3487 }
3488 memcpy(copy, data, DATASIZE);
3489 return new wxImage(width, height, copy, false);
3490 }
3491 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3492 if (DATASIZE != width*height*3) {
3493 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3494 return NULL;
3495 }
3496 if (ALPHASIZE != width*height) {
3497 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3498 return NULL;
3499 }
3500
3501 // Copy the source data so the wxImage can clean it up later
3502 buffer dcopy = (buffer)malloc(DATASIZE);
3503 if (dcopy == NULL) {
3504 wxPyBLOCK_THREADS(PyErr_NoMemory());
3505 return NULL;
3506 }
3507 memcpy(dcopy, data, DATASIZE);
3508
3509 buffer acopy = (buffer)malloc(ALPHASIZE);
3510 if (acopy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(acopy, alpha, ALPHASIZE);
3515
3516 return new wxImage(width, height, dcopy, acopy, false);
3517 }
3518 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3519 wxSize size(self->GetWidth(), self->GetHeight());
3520 return size;
3521 }
3522 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3523 buffer data = self->GetData();
3524 int len = self->GetWidth() * self->GetHeight() * 3;
3525 PyObject* rv;
3526 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3527 return rv;
3528 }
3529 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3530 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3531 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3532 return;
3533 }
3534 buffer copy = (buffer)malloc(DATASIZE);
3535 if (copy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return;
3538 }
3539 memcpy(copy, data, DATASIZE);
3540 self->SetData(copy, false);
3541 // wxImage takes ownership of copy...
3542 }
3543 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3544 buffer data = self->GetData();
3545 int len = self->GetWidth() * self->GetHeight() * 3;
3546 PyObject* rv;
3547 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3548 return rv;
3549 }
3550 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3551 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3552 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3553 return;
3554 }
3555 self->SetData(data, true);
3556 }
3557 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3558 buffer data = self->GetAlpha();
3559 if (! data) {
3560 RETURN_NONE();
3561 } else {
3562 int len = self->GetWidth() * self->GetHeight();
3563 PyObject* rv;
3564 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3565 return rv;
3566 }
3567 }
3568 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3569 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3570 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3571 return;
3572 }
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579 self->SetAlpha(acopy, false);
3580 // wxImage takes ownership of acopy...
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 int len = self->GetWidth() * self->GetHeight();
3585 PyObject* rv;
3586 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3587 return rv;
3588 }
3589 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3590 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3591 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3592 return;
3593 }
3594 self->SetAlpha(alpha, true);
3595 }
3596 SWIGINTERN PyObject *wxImage_GetHandlers(){
3597 wxList& list = wxImage::GetHandlers();
3598 return wxPy_ConvertList(&list);
3599 }
3600 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3601 wxBitmap bitmap(*self, depth);
3602 return bitmap;
3603 }
3604 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3605 wxImage mono = self->ConvertToMono( red, green, blue );
3606 wxBitmap bitmap( mono, 1 );
3607 return bitmap;
3608 }
3609 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3610 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3612 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3616 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3617 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3618 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3619 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3620 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3621 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3622 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3623 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3624
3625 #include <wx/quantize.h>
3626
3627 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3628 return wxQuantize::Quantize(src, dest,
3629 //NULL, // palette
3630 desiredNoColours,
3631 NULL, // eightBitData
3632 flags);
3633 }
3634 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3635 if (PyCallable_Check(func)) {
3636 self->Connect(id, lastId, eventType,
3637 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3638 new wxPyCallback(func));
3639 }
3640 else if (func == Py_None) {
3641 self->Disconnect(id, lastId, eventType,
3642 (wxObjectEventFunction)
3643 &wxPyCallback::EventThunker);
3644 }
3645 else {
3646 wxPyBLOCK_THREADS(
3647 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3648 }
3649 }
3650 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3651 return self->Disconnect(id, lastId, eventType,
3652 (wxObjectEventFunction)
3653 &wxPyCallback::EventThunker);
3654 }
3655 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3656 if (_self && _self != Py_None) {
3657 self->SetClientObject(new wxPyOORClientData(_self, incref));
3658 }
3659 else {
3660 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3661 if (data) {
3662 self->SetClientObject(NULL); // This will delete it too
3663 }
3664 }
3665 }
3666
3667 #if ! wxUSE_HOTKEY
3668 #define wxEVT_HOTKEY -9999
3669 #endif
3670
3671 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3672 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3673 if (data) {
3674 Py_INCREF(data->m_obj);
3675 return data->m_obj;
3676 } else {
3677 Py_INCREF(Py_None);
3678 return Py_None;
3679 }
3680 }
3681 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3682 wxPyClientData* data = new wxPyClientData(clientData);
3683 self->SetClientObject(data);
3684 }
3685 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3686 #if wxUSE_UNICODE
3687 return self->GetUnicodeKey();
3688 #else
3689 return 0;
3690 #endif
3691 }
3692
3693 SWIGINTERNINLINE PyObject *
3694 SWIG_From_unsigned_SS_int (unsigned int value)
3695 {
3696 return SWIG_From_unsigned_SS_long (value);
3697 }
3698
3699
3700 SWIGINTERN int
3701 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3702 {
3703 unsigned long v;
3704 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3705 if (SWIG_IsOK(res)) {
3706 if ((v > UINT_MAX)) {
3707 return SWIG_OverflowError;
3708 } else {
3709 if (val) *val = static_cast< unsigned int >(v);
3710 }
3711 }
3712 return res;
3713 }
3714
3715 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3716 self->m_size = size;
3717 }
3718 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3719 int count = self->GetNumberOfFiles();
3720 wxString* files = self->GetFiles();
3721 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3722 PyObject* list = PyList_New(count);
3723
3724 if (!list) {
3725 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3726 wxPyEndBlockThreads(blocked);
3727 return NULL;
3728 }
3729
3730 for (int i=0; i<count; i++) {
3731 PyList_SetItem(list, i, wx2PyString(files[i]));
3732 }
3733 wxPyEndBlockThreads(blocked);
3734 return list;
3735 }
3736
3737
3738 SWIGINTERN wxPyApp *new_wxPyApp(){
3739 wxPythonApp = new wxPyApp();
3740 return wxPythonApp;
3741 }
3742
3743 void wxApp_CleanUp() {
3744 __wxPyCleanup();
3745 }
3746
3747
3748 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3749
3750
3751
3752
3753
3754 SWIGINTERNINLINE PyObject *
3755 SWIG_FromCharPtr(const char *cptr)
3756 {
3757 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3758 }
3759
3760
3761 #if 0 // #ifdef __WXMAC__
3762
3763 // A dummy class that raises an exception if used...
3764 class wxEventLoop
3765 {
3766 public:
3767 wxEventLoop() { wxPyRaiseNotImplemented(); }
3768 int Run() { return 0; }
3769 void Exit(int rc = 0) {}
3770 bool Pending() const { return false; }
3771 bool Dispatch() { return false; }
3772 bool IsRunning() const { return false; }
3773 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3774 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3775 };
3776
3777 #else
3778
3779 #include <wx/evtloop.h>
3780
3781 #endif
3782
3783
3784
3785 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3786 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3787 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3788 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3789 wxWindowList& list = self->GetChildren();
3790 return wxPy_ConvertList(&list);
3791 }
3792 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3793 #if wxUSE_HOTKEY
3794 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3795 #else
3796 return false;
3797 #endif
3798 }
3799 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3800
3801
3802
3803 return false;
3804
3805 }
3806 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3807 return wxPyGetWinHandle(self);
3808 }
3809 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3810 self->AssociateHandle((WXWidget)handle);
3811 }
3812
3813 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3814 return wxWindow::FindWindowById(id, parent);
3815 }
3816
3817 wxWindow* wxFindWindowByName( const wxString& name,
3818 const wxWindow *parent = NULL ) {
3819 return wxWindow::FindWindowByName(name, parent);
3820 }
3821
3822 wxWindow* wxFindWindowByLabel( const wxString& label,
3823 const wxWindow *parent = NULL ) {
3824 return wxWindow::FindWindowByLabel(label, parent);
3825 }
3826
3827
3828 #ifdef __WXMSW__
3829 #include <wx/msw/private.h> // to get wxGetWindowId
3830 #endif
3831
3832
3833 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3834 #ifdef __WXMSW__
3835 WXHWND hWnd = (WXHWND)_hWnd;
3836 long id = wxGetWindowId(hWnd);
3837 wxWindow* win = new wxWindow;
3838 if (parent)
3839 parent->AddChild(win);
3840 win->SetEventHandler(win);
3841 win->SetHWND(hWnd);
3842 win->SetId(id);
3843 win->SubclassWin(hWnd);
3844 win->AdoptAttributesFromHWND();
3845 win->SetupColours();
3846 return win;
3847 #else
3848 wxPyRaiseNotImplemented();
3849 return NULL;
3850 #endif
3851 }
3852
3853
3854 PyObject* GetTopLevelWindows() {
3855 return wxPy_ConvertList(&wxTopLevelWindows);
3856 }
3857
3858
3859 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3860 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3862
3863 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3864
3865
3866 SWIGINTERNINLINE int
3867 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3868 {
3869 unsigned long v;
3870 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3871 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3872 return res;
3873 }
3874
3875 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3876 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3877 wxMenuItemList& list = self->GetMenuItems();
3878 return wxPy_ConvertList(&list);
3879 }
3880 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3881 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3882 static const wxString wxPyControlNameStr(wxControlNameStr);
3883 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3884 if (clientData) {
3885 wxPyClientData* data = new wxPyClientData(clientData);
3886 return self->Append(item, data);
3887 } else
3888 return self->Append(item);
3889 }
3890 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3891 if (clientData) {
3892 wxPyClientData* data = new wxPyClientData(clientData);
3893 return self->Insert(item, pos, data);
3894 } else
3895 return self->Insert(item, pos);
3896 }
3897 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3898 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3899 if (data) {
3900 Py_INCREF(data->m_obj);
3901 return data->m_obj;
3902 } else {
3903 Py_INCREF(Py_None);
3904 return Py_None;
3905 }
3906 }
3907 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3908 wxPyClientData* data = new wxPyClientData(clientData);
3909 self->SetClientObject(n, data);
3910 }
3911
3912
3913 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3914 wxPyUserData* data = NULL;
3915 if ( userData ) {
3916 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3917 data = new wxPyUserData(userData);
3918 wxPyEndBlockThreads(blocked);
3919 }
3920 return new wxSizerItem(window, proportion, flag, border, data);
3921 }
3922 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3923 wxPyUserData* data = NULL;
3924 if ( userData ) {
3925 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3926 data = new wxPyUserData(userData);
3927 wxPyEndBlockThreads(blocked);
3928 }
3929 return new wxSizerItem(width, height, proportion, flag, border, data);
3930 }
3931 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3932 wxPyUserData* data = NULL;
3933 if ( userData ) {
3934 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3935 data = new wxPyUserData(userData);
3936 wxPyEndBlockThreads(blocked);
3937 }
3938 return new wxSizerItem(sizer, proportion, flag, border, data);
3939 }
3940
3941 #include <float.h>
3942
3943
3944 SWIGINTERN int
3945 SWIG_AsVal_float (PyObject * obj, float *val)
3946 {
3947 double v;
3948 int res = SWIG_AsVal_double (obj, &v);
3949 if (SWIG_IsOK(res)) {
3950 if ((v < -FLT_MAX || v > FLT_MAX)) {
3951 return SWIG_OverflowError;
3952 } else {
3953 if (val) *val = static_cast< float >(v);
3954 }
3955 }
3956 return res;
3957 }
3958
3959
3960 SWIGINTERNINLINE PyObject *
3961 SWIG_From_float (float value)
3962 {
3963 return SWIG_From_double (value);
3964 }
3965
3966 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3967 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3968 if (data) {
3969 Py_INCREF(data->m_obj);
3970 return data->m_obj;
3971 } else {
3972 Py_INCREF(Py_None);
3973 return Py_None;
3974 }
3975 }
3976 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3977 wxPyUserData* data = NULL;
3978 if ( userData ) {
3979 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3980 data = new wxPyUserData(userData);
3981 wxPyEndBlockThreads(blocked);
3982 }
3983 self->SetUserData(data);
3984 }
3985
3986 // Figure out the type of the sizer item
3987
3988 struct wxPySizerItemInfo {
3989 wxPySizerItemInfo()
3990 : window(NULL), sizer(NULL), gotSize(false),
3991 size(wxDefaultSize), gotPos(false), pos(-1)
3992 {}
3993
3994 wxWindow* window;
3995 wxSizer* sizer;
3996 bool gotSize;
3997 wxSize size;
3998 bool gotPos;
3999 int pos;
4000 };
4001
4002 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4003
4004 wxPySizerItemInfo info;
4005 wxSize size;
4006 wxSize* sizePtr = &size;
4007
4008 // Find out what the type of the item is
4009 // try wxWindow
4010 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4011 PyErr_Clear();
4012 info.window = NULL;
4013
4014 // try wxSizer
4015 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4016 PyErr_Clear();
4017 info.sizer = NULL;
4018
4019 // try wxSize or (w,h)
4020 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4021 info.size = *sizePtr;
4022 info.gotSize = true;
4023 }
4024
4025 // or a single int
4026 if (checkIdx && PyInt_Check(item)) {
4027 info.pos = PyInt_AsLong(item);
4028 info.gotPos = true;
4029 }
4030 }
4031 }
4032
4033 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4034 // no expected type, figure out what kind of error message to generate
4035 if ( !checkSize && !checkIdx )
4036 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4037 else if ( checkSize && !checkIdx )
4038 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4039 else if ( !checkSize && checkIdx)
4040 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4041 else
4042 // can this one happen?
4043 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4044 }
4045
4046 return info;
4047 }
4048
4049 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4050 if (!self->GetClientObject())
4051 self->SetClientObject(new wxPyOORClientData(_self));
4052 }
4053 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4054
4055 wxPyUserData* data = NULL;
4056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4058 if ( userData && (info.window || info.sizer || info.gotSize) )
4059 data = new wxPyUserData(userData);
4060 if ( info.sizer )
4061 PyObject_SetAttrString(item,"thisown",Py_False);
4062 wxPyEndBlockThreads(blocked);
4063
4064 // Now call the real Add method if a valid item type was found
4065 if ( info.window )
4066 return self->Add(info.window, proportion, flag, border, data);
4067 else if ( info.sizer )
4068 return self->Add(info.sizer, proportion, flag, border, data);
4069 else if (info.gotSize)
4070 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4071 proportion, flag, border, data);
4072 else
4073 return NULL;
4074 }
4075 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4076
4077 wxPyUserData* data = NULL;
4078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4079 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4080 if ( userData && (info.window || info.sizer || info.gotSize) )
4081 data = new wxPyUserData(userData);
4082 if ( info.sizer )
4083 PyObject_SetAttrString(item,"thisown",Py_False);
4084 wxPyEndBlockThreads(blocked);
4085
4086 // Now call the real Insert method if a valid item type was found
4087 if ( info.window )
4088 return self->Insert(before, info.window, proportion, flag, border, data);
4089 else if ( info.sizer )
4090 return self->Insert(before, info.sizer, proportion, flag, border, data);
4091 else if (info.gotSize)
4092 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4093 proportion, flag, border, data);
4094 else
4095 return NULL;
4096 }
4097 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4098
4099 wxPyUserData* data = NULL;
4100 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4101 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4102 if ( userData && (info.window || info.sizer || info.gotSize) )
4103 data = new wxPyUserData(userData);
4104 if ( info.sizer )
4105 PyObject_SetAttrString(item,"thisown",Py_False);
4106 wxPyEndBlockThreads(blocked);
4107
4108 // Now call the real Prepend method if a valid item type was found
4109 if ( info.window )
4110 return self->Prepend(info.window, proportion, flag, border, data);
4111 else if ( info.sizer )
4112 return self->Prepend(info.sizer, proportion, flag, border, data);
4113 else if (info.gotSize)
4114 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4115 proportion, flag, border, data);
4116 else
4117 return NULL;
4118 }
4119 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4120 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4121 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4122 wxPyEndBlockThreads(blocked);
4123 if ( info.window )
4124 return self->Remove(info.window);
4125 else if ( info.sizer )
4126 return self->Remove(info.sizer);
4127 else if ( info.gotPos )
4128 return self->Remove(info.pos);
4129 else
4130 return false;
4131 }
4132 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4135 wxPyEndBlockThreads(blocked);
4136 if ( info.window )
4137 return self->Detach(info.window);
4138 else if ( info.sizer )
4139 return self->Detach(info.sizer);
4140 else if ( info.gotPos )
4141 return self->Detach(info.pos);
4142 else
4143 return false;
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4146 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4147 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4148 wxPyEndBlockThreads(blocked);
4149 if ( info.window )
4150 return self->GetItem(info.window);
4151 else if ( info.sizer )
4152 return self->GetItem(info.sizer);
4153 else if ( info.gotPos )
4154 return self->GetItem(info.pos);
4155 else
4156 return NULL;
4157 }
4158 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4161 wxPyEndBlockThreads(blocked);
4162 if ( info.window )
4163 self->SetItemMinSize(info.window, size);
4164 else if ( info.sizer )
4165 self->SetItemMinSize(info.sizer, size);
4166 else if ( info.gotPos )
4167 self->SetItemMinSize(info.pos, size);
4168 }
4169 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4170 wxSizerItemList& list = self->GetChildren();
4171 return wxPy_ConvertList(&list);
4172 }
4173 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4176 wxPyEndBlockThreads(blocked);
4177 if ( info.window )
4178 return self->Show(info.window, show, recursive);
4179 else if ( info.sizer )
4180 return self->Show(info.sizer, show, recursive);
4181 else if ( info.gotPos )
4182 return self->Show(info.pos, show);
4183 else
4184 return false;
4185 }
4186 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 return self->IsShown(info.window);
4192 else if ( info.sizer )
4193 return self->IsShown(info.sizer);
4194 else if ( info.gotPos )
4195 return self->IsShown(info.pos);
4196 else
4197 return false;
4198 }
4199
4200 // See pyclasses.h
4201 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4202 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4203 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4204
4205
4206
4207
4208 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4209 {
4210 if (source == Py_None) {
4211 **obj = wxGBPosition(-1,-1);
4212 return true;
4213 }
4214 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4215 }
4216
4217 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4218 {
4219 if (source == Py_None) {
4220 **obj = wxGBSpan(-1,-1);
4221 return true;
4222 }
4223 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4224 }
4225
4226
4227 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4228 wxGBPosition temp, *obj = &temp;
4229 if ( other == Py_None ) return false;
4230 if ( ! wxGBPosition_helper(other, &obj) ) {
4231 PyErr_Clear();
4232 return false;
4233 }
4234 return self->operator==(*obj);
4235 }
4236 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4237 wxGBPosition temp, *obj = &temp;
4238 if ( other == Py_None ) return true;
4239 if ( ! wxGBPosition_helper(other, &obj)) {
4240 PyErr_Clear();
4241 return true;
4242 }
4243 return self->operator!=(*obj);
4244 }
4245 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4246 self->SetRow(row);
4247 self->SetCol(col);
4248 }
4249 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 PyObject* tup = PyTuple_New(2);
4252 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4253 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4254 wxPyEndBlockThreads(blocked);
4255 return tup;
4256 }
4257 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4258 wxGBSpan temp, *obj = &temp;
4259 if ( other == Py_None ) return false;
4260 if ( ! wxGBSpan_helper(other, &obj) ) {
4261 PyErr_Clear();
4262 return false;
4263 }
4264 return self->operator==(*obj);
4265 }
4266 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4267 wxGBSpan temp, *obj = &temp;
4268 if ( other == Py_None ) return true;
4269 if ( ! wxGBSpan_helper(other, &obj)) {
4270 PyErr_Clear();
4271 return true;
4272 }
4273 return self->operator!=(*obj);
4274 }
4275 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4276 self->SetRowspan(rowspan);
4277 self->SetColspan(colspan);
4278 }
4279 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4280 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4281 PyObject* tup = PyTuple_New(2);
4282 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4283 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4284 wxPyEndBlockThreads(blocked);
4285 return tup;
4286 }
4287 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4288 wxPyUserData* data = NULL;
4289 if ( userData ) {
4290 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4291 data = new wxPyUserData(userData);
4292 wxPyEndBlockThreads(blocked);
4293 }
4294 return new wxGBSizerItem(window, pos, span, flag, border, data);
4295 }
4296 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4297 wxPyUserData* data = NULL;
4298 if ( userData ) {
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 data = new wxPyUserData(userData);
4301 wxPyEndBlockThreads(blocked);
4302 }
4303 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4304 }
4305 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4306 wxPyUserData* data = NULL;
4307 if ( userData ) {
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 data = new wxPyUserData(userData);
4310 wxPyEndBlockThreads(blocked);
4311 }
4312 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4313 }
4314 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4315 int row, col;
4316 self->GetEndPos(row, col);
4317 return wxGBPosition(row, col);
4318 }
4319 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4320
4321 wxPyUserData* data = NULL;
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4324 if ( userData && (info.window || info.sizer || info.gotSize) )
4325 data = new wxPyUserData(userData);
4326 if ( info.sizer )
4327 PyObject_SetAttrString(item,"thisown",Py_False);
4328 wxPyEndBlockThreads(blocked);
4329
4330 // Now call the real Add method if a valid item type was found
4331 if ( info.window )
4332 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4333 else if ( info.sizer )
4334 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4335 else if (info.gotSize)
4336 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4337 pos, span, flag, border, data);
4338 return NULL;
4339 }
4340
4341
4342 #ifdef __cplusplus
4343 extern "C" {
4344 #endif
4345 SWIGINTERN int EmptyString_set(PyObject *) {
4346 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4347 return 1;
4348 }
4349
4350
4351 SWIGINTERN PyObject *EmptyString_get(void) {
4352 PyObject *pyobj = 0;
4353
4354 {
4355 #if wxUSE_UNICODE
4356 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4357 #else
4358 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4359 #endif
4360 }
4361 return pyobj;
4362 }
4363
4364
4365 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4366 PyObject *resultobj = 0;
4367 wxObject *arg1 = (wxObject *) 0 ;
4368 wxString result;
4369 void *argp1 = 0 ;
4370 int res1 = 0 ;
4371 PyObject *swig_obj[1] ;
4372
4373 if (!args) SWIG_fail;
4374 swig_obj[0] = args;
4375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4376 if (!SWIG_IsOK(res1)) {
4377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4378 }
4379 arg1 = reinterpret_cast< wxObject * >(argp1);
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = wxObject_GetClassName(arg1);
4383 wxPyEndAllowThreads(__tstate);
4384 if (PyErr_Occurred()) SWIG_fail;
4385 }
4386 {
4387 #if wxUSE_UNICODE
4388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4389 #else
4390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4391 #endif
4392 }
4393 return resultobj;
4394 fail:
4395 return NULL;
4396 }
4397
4398
4399 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400 PyObject *resultobj = 0;
4401 wxObject *arg1 = (wxObject *) 0 ;
4402 void *argp1 = 0 ;
4403 int res1 = 0 ;
4404 PyObject *swig_obj[1] ;
4405
4406 if (!args) SWIG_fail;
4407 swig_obj[0] = args;
4408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4409 if (!SWIG_IsOK(res1)) {
4410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4411 }
4412 arg1 = reinterpret_cast< wxObject * >(argp1);
4413 {
4414 PyThreadState* __tstate = wxPyBeginAllowThreads();
4415 wxObject_Destroy(arg1);
4416 wxPyEndAllowThreads(__tstate);
4417 if (PyErr_Occurred()) SWIG_fail;
4418 }
4419 resultobj = SWIG_Py_Void();
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4427 PyObject *obj;
4428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4429 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4430 return SWIG_Py_Void();
4431 }
4432
4433 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434 PyObject *resultobj = 0;
4435 wxSize *arg1 = (wxSize *) 0 ;
4436 int arg2 ;
4437 void *argp1 = 0 ;
4438 int res1 = 0 ;
4439 int val2 ;
4440 int ecode2 = 0 ;
4441 PyObject *swig_obj[2] ;
4442
4443 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4445 if (!SWIG_IsOK(res1)) {
4446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4447 }
4448 arg1 = reinterpret_cast< wxSize * >(argp1);
4449 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4450 if (!SWIG_IsOK(ecode2)) {
4451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4452 }
4453 arg2 = static_cast< int >(val2);
4454 if (arg1) (arg1)->x = arg2;
4455
4456 resultobj = SWIG_Py_Void();
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4464 PyObject *resultobj = 0;
4465 wxSize *arg1 = (wxSize *) 0 ;
4466 int result;
4467 void *argp1 = 0 ;
4468 int res1 = 0 ;
4469 PyObject *swig_obj[1] ;
4470
4471 if (!args) SWIG_fail;
4472 swig_obj[0] = args;
4473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4474 if (!SWIG_IsOK(res1)) {
4475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4476 }
4477 arg1 = reinterpret_cast< wxSize * >(argp1);
4478 result = (int) ((arg1)->x);
4479 resultobj = SWIG_From_int(static_cast< int >(result));
4480 return resultobj;
4481 fail:
4482 return NULL;
4483 }
4484
4485
4486 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4487 PyObject *resultobj = 0;
4488 wxSize *arg1 = (wxSize *) 0 ;
4489 int arg2 ;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 int val2 ;
4493 int ecode2 = 0 ;
4494 PyObject *swig_obj[2] ;
4495
4496 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4498 if (!SWIG_IsOK(res1)) {
4499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4500 }
4501 arg1 = reinterpret_cast< wxSize * >(argp1);
4502 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4503 if (!SWIG_IsOK(ecode2)) {
4504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4505 }
4506 arg2 = static_cast< int >(val2);
4507 if (arg1) (arg1)->y = arg2;
4508
4509 resultobj = SWIG_Py_Void();
4510 return resultobj;
4511 fail:
4512 return NULL;
4513 }
4514
4515
4516 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4517 PyObject *resultobj = 0;
4518 wxSize *arg1 = (wxSize *) 0 ;
4519 int result;
4520 void *argp1 = 0 ;
4521 int res1 = 0 ;
4522 PyObject *swig_obj[1] ;
4523
4524 if (!args) SWIG_fail;
4525 swig_obj[0] = args;
4526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4527 if (!SWIG_IsOK(res1)) {
4528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4529 }
4530 arg1 = reinterpret_cast< wxSize * >(argp1);
4531 result = (int) ((arg1)->y);
4532 resultobj = SWIG_From_int(static_cast< int >(result));
4533 return resultobj;
4534 fail:
4535 return NULL;
4536 }
4537
4538
4539 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4540 PyObject *resultobj = 0;
4541 int arg1 = (int) 0 ;
4542 int arg2 = (int) 0 ;
4543 wxSize *result = 0 ;
4544 int val1 ;
4545 int ecode1 = 0 ;
4546 int val2 ;
4547 int ecode2 = 0 ;
4548 PyObject * obj0 = 0 ;
4549 PyObject * obj1 = 0 ;
4550 char * kwnames[] = {
4551 (char *) "w",(char *) "h", NULL
4552 };
4553
4554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4555 if (obj0) {
4556 ecode1 = SWIG_AsVal_int(obj0, &val1);
4557 if (!SWIG_IsOK(ecode1)) {
4558 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4559 }
4560 arg1 = static_cast< int >(val1);
4561 }
4562 if (obj1) {
4563 ecode2 = SWIG_AsVal_int(obj1, &val2);
4564 if (!SWIG_IsOK(ecode2)) {
4565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4566 }
4567 arg2 = static_cast< int >(val2);
4568 }
4569 {
4570 PyThreadState* __tstate = wxPyBeginAllowThreads();
4571 result = (wxSize *)new wxSize(arg1,arg2);
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4576 return resultobj;
4577 fail:
4578 return NULL;
4579 }
4580
4581
4582 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4583 PyObject *resultobj = 0;
4584 wxSize *arg1 = (wxSize *) 0 ;
4585 void *argp1 = 0 ;
4586 int res1 = 0 ;
4587 PyObject *swig_obj[1] ;
4588
4589 if (!args) SWIG_fail;
4590 swig_obj[0] = args;
4591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4592 if (!SWIG_IsOK(res1)) {
4593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4594 }
4595 arg1 = reinterpret_cast< wxSize * >(argp1);
4596 {
4597 PyThreadState* __tstate = wxPyBeginAllowThreads();
4598 delete arg1;
4599
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 resultobj = SWIG_Py_Void();
4604 return resultobj;
4605 fail:
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4611 PyObject *resultobj = 0;
4612 wxSize *arg1 = (wxSize *) 0 ;
4613 PyObject *arg2 = (PyObject *) 0 ;
4614 bool result;
4615 void *argp1 = 0 ;
4616 int res1 = 0 ;
4617 PyObject * obj0 = 0 ;
4618 PyObject * obj1 = 0 ;
4619 char * kwnames[] = {
4620 (char *) "self",(char *) "other", NULL
4621 };
4622
4623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4625 if (!SWIG_IsOK(res1)) {
4626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4627 }
4628 arg1 = reinterpret_cast< wxSize * >(argp1);
4629 arg2 = obj1;
4630 {
4631 result = (bool)wxSize___eq__(arg1,arg2);
4632 if (PyErr_Occurred()) SWIG_fail;
4633 }
4634 {
4635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4636 }
4637 return resultobj;
4638 fail:
4639 return NULL;
4640 }
4641
4642
4643 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4644 PyObject *resultobj = 0;
4645 wxSize *arg1 = (wxSize *) 0 ;
4646 PyObject *arg2 = (PyObject *) 0 ;
4647 bool result;
4648 void *argp1 = 0 ;
4649 int res1 = 0 ;
4650 PyObject * obj0 = 0 ;
4651 PyObject * obj1 = 0 ;
4652 char * kwnames[] = {
4653 (char *) "self",(char *) "other", NULL
4654 };
4655
4656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4658 if (!SWIG_IsOK(res1)) {
4659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4660 }
4661 arg1 = reinterpret_cast< wxSize * >(argp1);
4662 arg2 = obj1;
4663 {
4664 result = (bool)wxSize___ne__(arg1,arg2);
4665 if (PyErr_Occurred()) SWIG_fail;
4666 }
4667 {
4668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4669 }
4670 return resultobj;
4671 fail:
4672 return NULL;
4673 }
4674
4675
4676 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4677 PyObject *resultobj = 0;
4678 wxSize *arg1 = (wxSize *) 0 ;
4679 wxSize *arg2 = 0 ;
4680 wxSize result;
4681 void *argp1 = 0 ;
4682 int res1 = 0 ;
4683 wxSize temp2 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "self",(char *) "sz", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 {
4697 arg2 = &temp2;
4698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4699 }
4700 {
4701 PyThreadState* __tstate = wxPyBeginAllowThreads();
4702 result = (arg1)->operator +((wxSize const &)*arg2);
4703 wxPyEndAllowThreads(__tstate);
4704 if (PyErr_Occurred()) SWIG_fail;
4705 }
4706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4707 return resultobj;
4708 fail:
4709 return NULL;
4710 }
4711
4712
4713 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4714 PyObject *resultobj = 0;
4715 wxSize *arg1 = (wxSize *) 0 ;
4716 wxSize *arg2 = 0 ;
4717 wxSize result;
4718 void *argp1 = 0 ;
4719 int res1 = 0 ;
4720 wxSize temp2 ;
4721 PyObject * obj0 = 0 ;
4722 PyObject * obj1 = 0 ;
4723 char * kwnames[] = {
4724 (char *) "self",(char *) "sz", NULL
4725 };
4726
4727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4729 if (!SWIG_IsOK(res1)) {
4730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4731 }
4732 arg1 = reinterpret_cast< wxSize * >(argp1);
4733 {
4734 arg2 = &temp2;
4735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4736 }
4737 {
4738 PyThreadState* __tstate = wxPyBeginAllowThreads();
4739 result = (arg1)->operator -((wxSize const &)*arg2);
4740 wxPyEndAllowThreads(__tstate);
4741 if (PyErr_Occurred()) SWIG_fail;
4742 }
4743 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4744 return resultobj;
4745 fail:
4746 return NULL;
4747 }
4748
4749
4750 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4751 PyObject *resultobj = 0;
4752 wxSize *arg1 = (wxSize *) 0 ;
4753 wxSize *arg2 = 0 ;
4754 void *argp1 = 0 ;
4755 int res1 = 0 ;
4756 wxSize temp2 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "self",(char *) "sz", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4765 if (!SWIG_IsOK(res1)) {
4766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4767 }
4768 arg1 = reinterpret_cast< wxSize * >(argp1);
4769 {
4770 arg2 = &temp2;
4771 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4772 }
4773 {
4774 PyThreadState* __tstate = wxPyBeginAllowThreads();
4775 (arg1)->IncTo((wxSize const &)*arg2);
4776 wxPyEndAllowThreads(__tstate);
4777 if (PyErr_Occurred()) SWIG_fail;
4778 }
4779 resultobj = SWIG_Py_Void();
4780 return resultobj;
4781 fail:
4782 return NULL;
4783 }
4784
4785
4786 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4787 PyObject *resultobj = 0;
4788 wxSize *arg1 = (wxSize *) 0 ;
4789 wxSize *arg2 = 0 ;
4790 void *argp1 = 0 ;
4791 int res1 = 0 ;
4792 wxSize temp2 ;
4793 PyObject * obj0 = 0 ;
4794 PyObject * obj1 = 0 ;
4795 char * kwnames[] = {
4796 (char *) "self",(char *) "sz", NULL
4797 };
4798
4799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4801 if (!SWIG_IsOK(res1)) {
4802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4803 }
4804 arg1 = reinterpret_cast< wxSize * >(argp1);
4805 {
4806 arg2 = &temp2;
4807 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4808 }
4809 {
4810 PyThreadState* __tstate = wxPyBeginAllowThreads();
4811 (arg1)->DecTo((wxSize const &)*arg2);
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 resultobj = SWIG_Py_Void();
4816 return resultobj;
4817 fail:
4818 return NULL;
4819 }
4820
4821
4822 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4823 PyObject *resultobj = 0;
4824 wxSize *arg1 = (wxSize *) 0 ;
4825 int arg2 ;
4826 int arg3 ;
4827 void *argp1 = 0 ;
4828 int res1 = 0 ;
4829 int val2 ;
4830 int ecode2 = 0 ;
4831 int val3 ;
4832 int ecode3 = 0 ;
4833 PyObject * obj0 = 0 ;
4834 PyObject * obj1 = 0 ;
4835 PyObject * obj2 = 0 ;
4836 char * kwnames[] = {
4837 (char *) "self",(char *) "w",(char *) "h", NULL
4838 };
4839
4840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4842 if (!SWIG_IsOK(res1)) {
4843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4844 }
4845 arg1 = reinterpret_cast< wxSize * >(argp1);
4846 ecode2 = SWIG_AsVal_int(obj1, &val2);
4847 if (!SWIG_IsOK(ecode2)) {
4848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4849 }
4850 arg2 = static_cast< int >(val2);
4851 ecode3 = SWIG_AsVal_int(obj2, &val3);
4852 if (!SWIG_IsOK(ecode3)) {
4853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4854 }
4855 arg3 = static_cast< int >(val3);
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->Set(arg2,arg3);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 int arg2 ;
4873 void *argp1 = 0 ;
4874 int res1 = 0 ;
4875 int val2 ;
4876 int ecode2 = 0 ;
4877 PyObject * obj0 = 0 ;
4878 PyObject * obj1 = 0 ;
4879 char * kwnames[] = {
4880 (char *) "self",(char *) "w", NULL
4881 };
4882
4883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4885 if (!SWIG_IsOK(res1)) {
4886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4887 }
4888 arg1 = reinterpret_cast< wxSize * >(argp1);
4889 ecode2 = SWIG_AsVal_int(obj1, &val2);
4890 if (!SWIG_IsOK(ecode2)) {
4891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4892 }
4893 arg2 = static_cast< int >(val2);
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 (arg1)->SetWidth(arg2);
4897 wxPyEndAllowThreads(__tstate);
4898 if (PyErr_Occurred()) SWIG_fail;
4899 }
4900 resultobj = SWIG_Py_Void();
4901 return resultobj;
4902 fail:
4903 return NULL;
4904 }
4905
4906
4907 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4908 PyObject *resultobj = 0;
4909 wxSize *arg1 = (wxSize *) 0 ;
4910 int arg2 ;
4911 void *argp1 = 0 ;
4912 int res1 = 0 ;
4913 int val2 ;
4914 int ecode2 = 0 ;
4915 PyObject * obj0 = 0 ;
4916 PyObject * obj1 = 0 ;
4917 char * kwnames[] = {
4918 (char *) "self",(char *) "h", NULL
4919 };
4920
4921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4923 if (!SWIG_IsOK(res1)) {
4924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4925 }
4926 arg1 = reinterpret_cast< wxSize * >(argp1);
4927 ecode2 = SWIG_AsVal_int(obj1, &val2);
4928 if (!SWIG_IsOK(ecode2)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4930 }
4931 arg2 = static_cast< int >(val2);
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 (arg1)->SetHeight(arg2);
4935 wxPyEndAllowThreads(__tstate);
4936 if (PyErr_Occurred()) SWIG_fail;
4937 }
4938 resultobj = SWIG_Py_Void();
4939 return resultobj;
4940 fail:
4941 return NULL;
4942 }
4943
4944
4945 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4946 PyObject *resultobj = 0;
4947 wxSize *arg1 = (wxSize *) 0 ;
4948 int result;
4949 void *argp1 = 0 ;
4950 int res1 = 0 ;
4951 PyObject *swig_obj[1] ;
4952
4953 if (!args) SWIG_fail;
4954 swig_obj[0] = args;
4955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4956 if (!SWIG_IsOK(res1)) {
4957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4958 }
4959 arg1 = reinterpret_cast< wxSize * >(argp1);
4960 {
4961 PyThreadState* __tstate = wxPyBeginAllowThreads();
4962 result = (int)((wxSize const *)arg1)->GetWidth();
4963 wxPyEndAllowThreads(__tstate);
4964 if (PyErr_Occurred()) SWIG_fail;
4965 }
4966 resultobj = SWIG_From_int(static_cast< int >(result));
4967 return resultobj;
4968 fail:
4969 return NULL;
4970 }
4971
4972
4973 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4974 PyObject *resultobj = 0;
4975 wxSize *arg1 = (wxSize *) 0 ;
4976 int result;
4977 void *argp1 = 0 ;
4978 int res1 = 0 ;
4979 PyObject *swig_obj[1] ;
4980
4981 if (!args) SWIG_fail;
4982 swig_obj[0] = args;
4983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4984 if (!SWIG_IsOK(res1)) {
4985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4986 }
4987 arg1 = reinterpret_cast< wxSize * >(argp1);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 result = (int)((wxSize const *)arg1)->GetHeight();
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_From_int(static_cast< int >(result));
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 bool result;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 PyObject *swig_obj[1] ;
5008
5009 if (!args) SWIG_fail;
5010 swig_obj[0] = args;
5011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5012 if (!SWIG_IsOK(res1)) {
5013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5014 }
5015 arg1 = reinterpret_cast< wxSize * >(argp1);
5016 {
5017 PyThreadState* __tstate = wxPyBeginAllowThreads();
5018 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5019 wxPyEndAllowThreads(__tstate);
5020 if (PyErr_Occurred()) SWIG_fail;
5021 }
5022 {
5023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5024 }
5025 return resultobj;
5026 fail:
5027 return NULL;
5028 }
5029
5030
5031 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5032 PyObject *resultobj = 0;
5033 wxSize *arg1 = (wxSize *) 0 ;
5034 wxSize *arg2 = 0 ;
5035 void *argp1 = 0 ;
5036 int res1 = 0 ;
5037 wxSize temp2 ;
5038 PyObject * obj0 = 0 ;
5039 PyObject * obj1 = 0 ;
5040 char * kwnames[] = {
5041 (char *) "self",(char *) "size", NULL
5042 };
5043
5044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5046 if (!SWIG_IsOK(res1)) {
5047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5048 }
5049 arg1 = reinterpret_cast< wxSize * >(argp1);
5050 {
5051 arg2 = &temp2;
5052 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5053 }
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 (arg1)->SetDefaults((wxSize const &)*arg2);
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_Py_Void();
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 wxSize *arg1 = (wxSize *) 0 ;
5070 PyObject *result = 0 ;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 PyObject *swig_obj[1] ;
5074
5075 if (!args) SWIG_fail;
5076 swig_obj[0] = args;
5077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (PyObject *)wxSize_Get(arg1);
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = result;
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *obj;
5097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5098 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5099 return SWIG_Py_Void();
5100 }
5101
5102 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5103 return SWIG_Python_InitShadowInstance(args);
5104 }
5105
5106 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5107 PyObject *resultobj = 0;
5108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5109 double arg2 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 double val2 ;
5113 int ecode2 = 0 ;
5114 PyObject *swig_obj[2] ;
5115
5116 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5118 if (!SWIG_IsOK(res1)) {
5119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5120 }
5121 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5122 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5123 if (!SWIG_IsOK(ecode2)) {
5124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5125 }
5126 arg2 = static_cast< double >(val2);
5127 if (arg1) (arg1)->x = arg2;
5128
5129 resultobj = SWIG_Py_Void();
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5139 double result;
5140 void *argp1 = 0 ;
5141 int res1 = 0 ;
5142 PyObject *swig_obj[1] ;
5143
5144 if (!args) SWIG_fail;
5145 swig_obj[0] = args;
5146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5149 }
5150 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5151 result = (double) ((arg1)->x);
5152 resultobj = SWIG_From_double(static_cast< double >(result));
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5160 PyObject *resultobj = 0;
5161 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5162 double arg2 ;
5163 void *argp1 = 0 ;
5164 int res1 = 0 ;
5165 double val2 ;
5166 int ecode2 = 0 ;
5167 PyObject *swig_obj[2] ;
5168
5169 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5171 if (!SWIG_IsOK(res1)) {
5172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5173 }
5174 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5175 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5176 if (!SWIG_IsOK(ecode2)) {
5177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5178 }
5179 arg2 = static_cast< double >(val2);
5180 if (arg1) (arg1)->y = arg2;
5181
5182 resultobj = SWIG_Py_Void();
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *resultobj = 0;
5191 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5192 double result;
5193 void *argp1 = 0 ;
5194 int res1 = 0 ;
5195 PyObject *swig_obj[1] ;
5196
5197 if (!args) SWIG_fail;
5198 swig_obj[0] = args;
5199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5200 if (!SWIG_IsOK(res1)) {
5201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5202 }
5203 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5204 result = (double) ((arg1)->y);
5205 resultobj = SWIG_From_double(static_cast< double >(result));
5206 return resultobj;
5207 fail:
5208 return NULL;
5209 }
5210
5211
5212 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5213 PyObject *resultobj = 0;
5214 double arg1 = (double) 0.0 ;
5215 double arg2 = (double) 0.0 ;
5216 wxRealPoint *result = 0 ;
5217 double val1 ;
5218 int ecode1 = 0 ;
5219 double val2 ;
5220 int ecode2 = 0 ;
5221 PyObject * obj0 = 0 ;
5222 PyObject * obj1 = 0 ;
5223 char * kwnames[] = {
5224 (char *) "x",(char *) "y", NULL
5225 };
5226
5227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5228 if (obj0) {
5229 ecode1 = SWIG_AsVal_double(obj0, &val1);
5230 if (!SWIG_IsOK(ecode1)) {
5231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5232 }
5233 arg1 = static_cast< double >(val1);
5234 }
5235 if (obj1) {
5236 ecode2 = SWIG_AsVal_double(obj1, &val2);
5237 if (!SWIG_IsOK(ecode2)) {
5238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5239 }
5240 arg2 = static_cast< double >(val2);
5241 }
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5256 PyObject *resultobj = 0;
5257 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5258 void *argp1 = 0 ;
5259 int res1 = 0 ;
5260 PyObject *swig_obj[1] ;
5261
5262 if (!args) SWIG_fail;
5263 swig_obj[0] = args;
5264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5265 if (!SWIG_IsOK(res1)) {
5266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5267 }
5268 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5269 {
5270 PyThreadState* __tstate = wxPyBeginAllowThreads();
5271 delete arg1;
5272
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 PyObject *arg2 = (PyObject *) 0 ;
5287 bool result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 PyObject * obj0 = 0 ;
5291 PyObject * obj1 = 0 ;
5292 char * kwnames[] = {
5293 (char *) "self",(char *) "other", NULL
5294 };
5295
5296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5298 if (!SWIG_IsOK(res1)) {
5299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5300 }
5301 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5302 arg2 = obj1;
5303 {
5304 result = (bool)wxRealPoint___eq__(arg1,arg2);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 {
5308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5309 }
5310 return resultobj;
5311 fail:
5312 return NULL;
5313 }
5314
5315
5316 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5317 PyObject *resultobj = 0;
5318 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5319 PyObject *arg2 = (PyObject *) 0 ;
5320 bool result;
5321 void *argp1 = 0 ;
5322 int res1 = 0 ;
5323 PyObject * obj0 = 0 ;
5324 PyObject * obj1 = 0 ;
5325 char * kwnames[] = {
5326 (char *) "self",(char *) "other", NULL
5327 };
5328
5329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5331 if (!SWIG_IsOK(res1)) {
5332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5333 }
5334 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5335 arg2 = obj1;
5336 {
5337 result = (bool)wxRealPoint___ne__(arg1,arg2);
5338 if (PyErr_Occurred()) SWIG_fail;
5339 }
5340 {
5341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5342 }
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 wxRealPoint *arg2 = 0 ;
5353 wxRealPoint result;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 wxRealPoint temp2 ;
5357 PyObject * obj0 = 0 ;
5358 PyObject * obj1 = 0 ;
5359 char * kwnames[] = {
5360 (char *) "self",(char *) "pt", NULL
5361 };
5362
5363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5365 if (!SWIG_IsOK(res1)) {
5366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5367 }
5368 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5369 {
5370 arg2 = &temp2;
5371 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5372 }
5373 {
5374 PyThreadState* __tstate = wxPyBeginAllowThreads();
5375 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5387 PyObject *resultobj = 0;
5388 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5389 wxRealPoint *arg2 = 0 ;
5390 wxRealPoint result;
5391 void *argp1 = 0 ;
5392 int res1 = 0 ;
5393 wxRealPoint temp2 ;
5394 PyObject * obj0 = 0 ;
5395 PyObject * obj1 = 0 ;
5396 char * kwnames[] = {
5397 (char *) "self",(char *) "pt", NULL
5398 };
5399
5400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5402 if (!SWIG_IsOK(res1)) {
5403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5404 }
5405 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5406 {
5407 arg2 = &temp2;
5408 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5409 }
5410 {
5411 PyThreadState* __tstate = wxPyBeginAllowThreads();
5412 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5413 wxPyEndAllowThreads(__tstate);
5414 if (PyErr_Occurred()) SWIG_fail;
5415 }
5416 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj = 0;
5425 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5426 double arg2 ;
5427 double arg3 ;
5428 void *argp1 = 0 ;
5429 int res1 = 0 ;
5430 double val2 ;
5431 int ecode2 = 0 ;
5432 double val3 ;
5433 int ecode3 = 0 ;
5434 PyObject * obj0 = 0 ;
5435 PyObject * obj1 = 0 ;
5436 PyObject * obj2 = 0 ;
5437 char * kwnames[] = {
5438 (char *) "self",(char *) "x",(char *) "y", NULL
5439 };
5440
5441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5443 if (!SWIG_IsOK(res1)) {
5444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5445 }
5446 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5447 ecode2 = SWIG_AsVal_double(obj1, &val2);
5448 if (!SWIG_IsOK(ecode2)) {
5449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5450 }
5451 arg2 = static_cast< double >(val2);
5452 ecode3 = SWIG_AsVal_double(obj2, &val3);
5453 if (!SWIG_IsOK(ecode3)) {
5454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5455 }
5456 arg3 = static_cast< double >(val3);
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 wxRealPoint_Set(arg1,arg2,arg3);
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 resultobj = SWIG_Py_Void();
5464 return resultobj;
5465 fail:
5466 return NULL;
5467 }
5468
5469
5470 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5471 PyObject *resultobj = 0;
5472 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5473 PyObject *result = 0 ;
5474 void *argp1 = 0 ;
5475 int res1 = 0 ;
5476 PyObject *swig_obj[1] ;
5477
5478 if (!args) SWIG_fail;
5479 swig_obj[0] = args;
5480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5481 if (!SWIG_IsOK(res1)) {
5482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5483 }
5484 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = (PyObject *)wxRealPoint_Get(arg1);
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = result;
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499 PyObject *obj;
5500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5501 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5502 return SWIG_Py_Void();
5503 }
5504
5505 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 return SWIG_Python_InitShadowInstance(args);
5507 }
5508
5509 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5510 PyObject *resultobj = 0;
5511 wxPoint *arg1 = (wxPoint *) 0 ;
5512 int arg2 ;
5513 void *argp1 = 0 ;
5514 int res1 = 0 ;
5515 int val2 ;
5516 int ecode2 = 0 ;
5517 PyObject *swig_obj[2] ;
5518
5519 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxPoint * >(argp1);
5525 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5526 if (!SWIG_IsOK(ecode2)) {
5527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5528 }
5529 arg2 = static_cast< int >(val2);
5530 if (arg1) (arg1)->x = arg2;
5531
5532 resultobj = SWIG_Py_Void();
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5540 PyObject *resultobj = 0;
5541 wxPoint *arg1 = (wxPoint *) 0 ;
5542 int result;
5543 void *argp1 = 0 ;
5544 int res1 = 0 ;
5545 PyObject *swig_obj[1] ;
5546
5547 if (!args) SWIG_fail;
5548 swig_obj[0] = args;
5549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5550 if (!SWIG_IsOK(res1)) {
5551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5552 }
5553 arg1 = reinterpret_cast< wxPoint * >(argp1);
5554 result = (int) ((arg1)->x);
5555 resultobj = SWIG_From_int(static_cast< int >(result));
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5563 PyObject *resultobj = 0;
5564 wxPoint *arg1 = (wxPoint *) 0 ;
5565 int arg2 ;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 int val2 ;
5569 int ecode2 = 0 ;
5570 PyObject *swig_obj[2] ;
5571
5572 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5574 if (!SWIG_IsOK(res1)) {
5575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5576 }
5577 arg1 = reinterpret_cast< wxPoint * >(argp1);
5578 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5579 if (!SWIG_IsOK(ecode2)) {
5580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5581 }
5582 arg2 = static_cast< int >(val2);
5583 if (arg1) (arg1)->y = arg2;
5584
5585 resultobj = SWIG_Py_Void();
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594 wxPoint *arg1 = (wxPoint *) 0 ;
5595 int result;
5596 void *argp1 = 0 ;
5597 int res1 = 0 ;
5598 PyObject *swig_obj[1] ;
5599
5600 if (!args) SWIG_fail;
5601 swig_obj[0] = args;
5602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxPoint * >(argp1);
5607 result = (int) ((arg1)->y);
5608 resultobj = SWIG_From_int(static_cast< int >(result));
5609 return resultobj;
5610 fail:
5611 return NULL;
5612 }
5613
5614
5615 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5616 PyObject *resultobj = 0;
5617 int arg1 = (int) 0 ;
5618 int arg2 = (int) 0 ;
5619 wxPoint *result = 0 ;
5620 int val1 ;
5621 int ecode1 = 0 ;
5622 int val2 ;
5623 int ecode2 = 0 ;
5624 PyObject * obj0 = 0 ;
5625 PyObject * obj1 = 0 ;
5626 char * kwnames[] = {
5627 (char *) "x",(char *) "y", NULL
5628 };
5629
5630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5631 if (obj0) {
5632 ecode1 = SWIG_AsVal_int(obj0, &val1);
5633 if (!SWIG_IsOK(ecode1)) {
5634 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5635 }
5636 arg1 = static_cast< int >(val1);
5637 }
5638 if (obj1) {
5639 ecode2 = SWIG_AsVal_int(obj1, &val2);
5640 if (!SWIG_IsOK(ecode2)) {
5641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5642 }
5643 arg2 = static_cast< int >(val2);
5644 }
5645 {
5646 PyThreadState* __tstate = wxPyBeginAllowThreads();
5647 result = (wxPoint *)new wxPoint(arg1,arg2);
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5659 PyObject *resultobj = 0;
5660 wxPoint *arg1 = (wxPoint *) 0 ;
5661 void *argp1 = 0 ;
5662 int res1 = 0 ;
5663 PyObject *swig_obj[1] ;
5664
5665 if (!args) SWIG_fail;
5666 swig_obj[0] = args;
5667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5670 }
5671 arg1 = reinterpret_cast< wxPoint * >(argp1);
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 delete arg1;
5675
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 resultobj = SWIG_Py_Void();
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 PyObject *arg2 = (PyObject *) 0 ;
5690 bool result;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 char * kwnames[] = {
5696 (char *) "self",(char *) "other", NULL
5697 };
5698
5699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5701 if (!SWIG_IsOK(res1)) {
5702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5703 }
5704 arg1 = reinterpret_cast< wxPoint * >(argp1);
5705 arg2 = obj1;
5706 {
5707 result = (bool)wxPoint___eq__(arg1,arg2);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 {
5711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5712 }
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj = 0;
5721 wxPoint *arg1 = (wxPoint *) 0 ;
5722 PyObject *arg2 = (PyObject *) 0 ;
5723 bool result;
5724 void *argp1 = 0 ;
5725 int res1 = 0 ;
5726 PyObject * obj0 = 0 ;
5727 PyObject * obj1 = 0 ;
5728 char * kwnames[] = {
5729 (char *) "self",(char *) "other", NULL
5730 };
5731
5732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5734 if (!SWIG_IsOK(res1)) {
5735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5736 }
5737 arg1 = reinterpret_cast< wxPoint * >(argp1);
5738 arg2 = obj1;
5739 {
5740 result = (bool)wxPoint___ne__(arg1,arg2);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 {
5744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5745 }
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 wxPoint *arg2 = 0 ;
5756 wxPoint result;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 wxPoint temp2 ;
5760 PyObject * obj0 = 0 ;
5761 PyObject * obj1 = 0 ;
5762 char * kwnames[] = {
5763 (char *) "self",(char *) "pt", NULL
5764 };
5765
5766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5768 if (!SWIG_IsOK(res1)) {
5769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5770 }
5771 arg1 = reinterpret_cast< wxPoint * >(argp1);
5772 {
5773 arg2 = &temp2;
5774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5775 }
5776 {
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 result = (arg1)->operator +((wxPoint const &)*arg2);
5779 wxPyEndAllowThreads(__tstate);
5780 if (PyErr_Occurred()) SWIG_fail;
5781 }
5782 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5783 return resultobj;
5784 fail:
5785 return NULL;
5786 }
5787
5788
5789 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5790 PyObject *resultobj = 0;
5791 wxPoint *arg1 = (wxPoint *) 0 ;
5792 wxPoint *arg2 = 0 ;
5793 wxPoint result;
5794 void *argp1 = 0 ;
5795 int res1 = 0 ;
5796 wxPoint temp2 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 char * kwnames[] = {
5800 (char *) "self",(char *) "pt", NULL
5801 };
5802
5803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5805 if (!SWIG_IsOK(res1)) {
5806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5807 }
5808 arg1 = reinterpret_cast< wxPoint * >(argp1);
5809 {
5810 arg2 = &temp2;
5811 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5812 }
5813 {
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 result = (arg1)->operator -((wxPoint const &)*arg2);
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj = 0;
5828 wxPoint *arg1 = (wxPoint *) 0 ;
5829 wxPoint *arg2 = 0 ;
5830 wxPoint *result = 0 ;
5831 void *argp1 = 0 ;
5832 int res1 = 0 ;
5833 wxPoint temp2 ;
5834 PyObject * obj0 = 0 ;
5835 PyObject * obj1 = 0 ;
5836 char * kwnames[] = {
5837 (char *) "self",(char *) "pt", NULL
5838 };
5839
5840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5842 if (!SWIG_IsOK(res1)) {
5843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5844 }
5845 arg1 = reinterpret_cast< wxPoint * >(argp1);
5846 {
5847 arg2 = &temp2;
5848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5849 }
5850 {
5851 PyThreadState* __tstate = wxPyBeginAllowThreads();
5852 {
5853 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5854 result = (wxPoint *) &_result_ref;
5855 }
5856 wxPyEndAllowThreads(__tstate);
5857 if (PyErr_Occurred()) SWIG_fail;
5858 }
5859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5867 PyObject *resultobj = 0;
5868 wxPoint *arg1 = (wxPoint *) 0 ;
5869 wxPoint *arg2 = 0 ;
5870 wxPoint *result = 0 ;
5871 void *argp1 = 0 ;
5872 int res1 = 0 ;
5873 wxPoint temp2 ;
5874 PyObject * obj0 = 0 ;
5875 PyObject * obj1 = 0 ;
5876 char * kwnames[] = {
5877 (char *) "self",(char *) "pt", NULL
5878 };
5879
5880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5882 if (!SWIG_IsOK(res1)) {
5883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5884 }
5885 arg1 = reinterpret_cast< wxPoint * >(argp1);
5886 {
5887 arg2 = &temp2;
5888 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5889 }
5890 {
5891 PyThreadState* __tstate = wxPyBeginAllowThreads();
5892 {
5893 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5894 result = (wxPoint *) &_result_ref;
5895 }
5896 wxPyEndAllowThreads(__tstate);
5897 if (PyErr_Occurred()) SWIG_fail;
5898 }
5899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5900 return resultobj;
5901 fail:
5902 return NULL;
5903 }
5904
5905
5906 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5907 PyObject *resultobj = 0;
5908 wxPoint *arg1 = (wxPoint *) 0 ;
5909 long arg2 ;
5910 long arg3 ;
5911 void *argp1 = 0 ;
5912 int res1 = 0 ;
5913 long val2 ;
5914 int ecode2 = 0 ;
5915 long val3 ;
5916 int ecode3 = 0 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 PyObject * obj2 = 0 ;
5920 char * kwnames[] = {
5921 (char *) "self",(char *) "x",(char *) "y", NULL
5922 };
5923
5924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5926 if (!SWIG_IsOK(res1)) {
5927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5928 }
5929 arg1 = reinterpret_cast< wxPoint * >(argp1);
5930 ecode2 = SWIG_AsVal_long(obj1, &val2);
5931 if (!SWIG_IsOK(ecode2)) {
5932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5933 }
5934 arg2 = static_cast< long >(val2);
5935 ecode3 = SWIG_AsVal_long(obj2, &val3);
5936 if (!SWIG_IsOK(ecode3)) {
5937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5938 }
5939 arg3 = static_cast< long >(val3);
5940 {
5941 PyThreadState* __tstate = wxPyBeginAllowThreads();
5942 wxPoint_Set(arg1,arg2,arg3);
5943 wxPyEndAllowThreads(__tstate);
5944 if (PyErr_Occurred()) SWIG_fail;
5945 }
5946 resultobj = SWIG_Py_Void();
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5954 PyObject *resultobj = 0;
5955 wxPoint *arg1 = (wxPoint *) 0 ;
5956 PyObject *result = 0 ;
5957 void *argp1 = 0 ;
5958 int res1 = 0 ;
5959 PyObject *swig_obj[1] ;
5960
5961 if (!args) SWIG_fail;
5962 swig_obj[0] = args;
5963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5964 if (!SWIG_IsOK(res1)) {
5965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5966 }
5967 arg1 = reinterpret_cast< wxPoint * >(argp1);
5968 {
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (PyObject *)wxPoint_Get(arg1);
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = result;
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5982 PyObject *obj;
5983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5984 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5985 return SWIG_Py_Void();
5986 }
5987
5988 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5989 return SWIG_Python_InitShadowInstance(args);
5990 }
5991
5992 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj = 0;
5994 int arg1 = (int) 0 ;
5995 int arg2 = (int) 0 ;
5996 int arg3 = (int) 0 ;
5997 int arg4 = (int) 0 ;
5998 wxRect *result = 0 ;
5999 int val1 ;
6000 int ecode1 = 0 ;
6001 int val2 ;
6002 int ecode2 = 0 ;
6003 int val3 ;
6004 int ecode3 = 0 ;
6005 int val4 ;
6006 int ecode4 = 0 ;
6007 PyObject * obj0 = 0 ;
6008 PyObject * obj1 = 0 ;
6009 PyObject * obj2 = 0 ;
6010 PyObject * obj3 = 0 ;
6011 char * kwnames[] = {
6012 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6013 };
6014
6015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6016 if (obj0) {
6017 ecode1 = SWIG_AsVal_int(obj0, &val1);
6018 if (!SWIG_IsOK(ecode1)) {
6019 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6020 }
6021 arg1 = static_cast< int >(val1);
6022 }
6023 if (obj1) {
6024 ecode2 = SWIG_AsVal_int(obj1, &val2);
6025 if (!SWIG_IsOK(ecode2)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6027 }
6028 arg2 = static_cast< int >(val2);
6029 }
6030 if (obj2) {
6031 ecode3 = SWIG_AsVal_int(obj2, &val3);
6032 if (!SWIG_IsOK(ecode3)) {
6033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6034 }
6035 arg3 = static_cast< int >(val3);
6036 }
6037 if (obj3) {
6038 ecode4 = SWIG_AsVal_int(obj3, &val4);
6039 if (!SWIG_IsOK(ecode4)) {
6040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6041 }
6042 arg4 = static_cast< int >(val4);
6043 }
6044 {
6045 PyThreadState* __tstate = wxPyBeginAllowThreads();
6046 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6058 PyObject *resultobj = 0;
6059 wxPoint *arg1 = 0 ;
6060 wxPoint *arg2 = 0 ;
6061 wxRect *result = 0 ;
6062 wxPoint temp1 ;
6063 wxPoint temp2 ;
6064 PyObject * obj0 = 0 ;
6065 PyObject * obj1 = 0 ;
6066 char * kwnames[] = {
6067 (char *) "topLeft",(char *) "bottomRight", NULL
6068 };
6069
6070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6071 {
6072 arg1 = &temp1;
6073 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6074 }
6075 {
6076 arg2 = &temp2;
6077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6078 }
6079 {
6080 PyThreadState* __tstate = wxPyBeginAllowThreads();
6081 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj = 0;
6094 wxPoint *arg1 = 0 ;
6095 wxSize *arg2 = 0 ;
6096 wxRect *result = 0 ;
6097 wxPoint temp1 ;
6098 wxSize temp2 ;
6099 PyObject * obj0 = 0 ;
6100 PyObject * obj1 = 0 ;
6101 char * kwnames[] = {
6102 (char *) "pos",(char *) "size", NULL
6103 };
6104
6105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6106 {
6107 arg1 = &temp1;
6108 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6109 }
6110 {
6111 arg2 = &temp2;
6112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6113 }
6114 {
6115 PyThreadState* __tstate = wxPyBeginAllowThreads();
6116 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6121 return resultobj;
6122 fail:
6123 return NULL;
6124 }
6125
6126
6127 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6128 PyObject *resultobj = 0;
6129 wxSize *arg1 = 0 ;
6130 wxRect *result = 0 ;
6131 wxSize temp1 ;
6132 PyObject * obj0 = 0 ;
6133 char * kwnames[] = {
6134 (char *) "size", NULL
6135 };
6136
6137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6138 {
6139 arg1 = &temp1;
6140 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6141 }
6142 {
6143 PyThreadState* __tstate = wxPyBeginAllowThreads();
6144 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6145 wxPyEndAllowThreads(__tstate);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156 PyObject *resultobj = 0;
6157 wxRect *arg1 = (wxRect *) 0 ;
6158 void *argp1 = 0 ;
6159 int res1 = 0 ;
6160 PyObject *swig_obj[1] ;
6161
6162 if (!args) SWIG_fail;
6163 swig_obj[0] = args;
6164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6165 if (!SWIG_IsOK(res1)) {
6166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6167 }
6168 arg1 = reinterpret_cast< wxRect * >(argp1);
6169 {
6170 PyThreadState* __tstate = wxPyBeginAllowThreads();
6171 delete arg1;
6172
6173 wxPyEndAllowThreads(__tstate);
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 resultobj = SWIG_Py_Void();
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6184 PyObject *resultobj = 0;
6185 wxRect *arg1 = (wxRect *) 0 ;
6186 int result;
6187 void *argp1 = 0 ;
6188 int res1 = 0 ;
6189 PyObject *swig_obj[1] ;
6190
6191 if (!args) SWIG_fail;
6192 swig_obj[0] = args;
6193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6194 if (!SWIG_IsOK(res1)) {
6195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6196 }
6197 arg1 = reinterpret_cast< wxRect * >(argp1);
6198 {
6199 PyThreadState* __tstate = wxPyBeginAllowThreads();
6200 result = (int)((wxRect const *)arg1)->GetX();
6201 wxPyEndAllowThreads(__tstate);
6202 if (PyErr_Occurred()) SWIG_fail;
6203 }
6204 resultobj = SWIG_From_int(static_cast< int >(result));
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj = 0;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int arg2 ;
6215 void *argp1 = 0 ;
6216 int res1 = 0 ;
6217 int val2 ;
6218 int ecode2 = 0 ;
6219 PyObject * obj0 = 0 ;
6220 PyObject * obj1 = 0 ;
6221 char * kwnames[] = {
6222 (char *) "self",(char *) "x", NULL
6223 };
6224
6225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6227 if (!SWIG_IsOK(res1)) {
6228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6229 }
6230 arg1 = reinterpret_cast< wxRect * >(argp1);
6231 ecode2 = SWIG_AsVal_int(obj1, &val2);
6232 if (!SWIG_IsOK(ecode2)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6234 }
6235 arg2 = static_cast< int >(val2);
6236 {
6237 PyThreadState* __tstate = wxPyBeginAllowThreads();
6238 (arg1)->SetX(arg2);
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 resultobj = SWIG_Py_Void();
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6250 PyObject *resultobj = 0;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 int result;
6253 void *argp1 = 0 ;
6254 int res1 = 0 ;
6255 PyObject *swig_obj[1] ;
6256
6257 if (!args) SWIG_fail;
6258 swig_obj[0] = args;
6259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6260 if (!SWIG_IsOK(res1)) {
6261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6262 }
6263 arg1 = reinterpret_cast< wxRect * >(argp1);
6264 {
6265 PyThreadState* __tstate = wxPyBeginAllowThreads();
6266 result = (int)(arg1)->GetY();
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_From_int(static_cast< int >(result));
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int arg2 ;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 int val2 ;
6284 int ecode2 = 0 ;
6285 PyObject * obj0 = 0 ;
6286 PyObject * obj1 = 0 ;
6287 char * kwnames[] = {
6288 (char *) "self",(char *) "y", NULL
6289 };
6290
6291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6293 if (!SWIG_IsOK(res1)) {
6294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6295 }
6296 arg1 = reinterpret_cast< wxRect * >(argp1);
6297 ecode2 = SWIG_AsVal_int(obj1, &val2);
6298 if (!SWIG_IsOK(ecode2)) {
6299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6300 }
6301 arg2 = static_cast< int >(val2);
6302 {
6303 PyThreadState* __tstate = wxPyBeginAllowThreads();
6304 (arg1)->SetY(arg2);
6305 wxPyEndAllowThreads(__tstate);
6306 if (PyErr_Occurred()) SWIG_fail;
6307 }
6308 resultobj = SWIG_Py_Void();
6309 return resultobj;
6310 fail:
6311 return NULL;
6312 }
6313
6314
6315 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6316 PyObject *resultobj = 0;
6317 wxRect *arg1 = (wxRect *) 0 ;
6318 int result;
6319 void *argp1 = 0 ;
6320 int res1 = 0 ;
6321 PyObject *swig_obj[1] ;
6322
6323 if (!args) SWIG_fail;
6324 swig_obj[0] = args;
6325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6326 if (!SWIG_IsOK(res1)) {
6327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6328 }
6329 arg1 = reinterpret_cast< wxRect * >(argp1);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 result = (int)((wxRect const *)arg1)->GetWidth();
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_From_int(static_cast< int >(result));
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int arg2 ;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 int val2 ;
6350 int ecode2 = 0 ;
6351 PyObject * obj0 = 0 ;
6352 PyObject * obj1 = 0 ;
6353 char * kwnames[] = {
6354 (char *) "self",(char *) "w", NULL
6355 };
6356
6357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6359 if (!SWIG_IsOK(res1)) {
6360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6361 }
6362 arg1 = reinterpret_cast< wxRect * >(argp1);
6363 ecode2 = SWIG_AsVal_int(obj1, &val2);
6364 if (!SWIG_IsOK(ecode2)) {
6365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6366 }
6367 arg2 = static_cast< int >(val2);
6368 {
6369 PyThreadState* __tstate = wxPyBeginAllowThreads();
6370 (arg1)->SetWidth(arg2);
6371 wxPyEndAllowThreads(__tstate);
6372 if (PyErr_Occurred()) SWIG_fail;
6373 }
6374 resultobj = SWIG_Py_Void();
6375 return resultobj;
6376 fail:
6377 return NULL;
6378 }
6379
6380
6381 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6382 PyObject *resultobj = 0;
6383 wxRect *arg1 = (wxRect *) 0 ;
6384 int result;
6385 void *argp1 = 0 ;
6386 int res1 = 0 ;
6387 PyObject *swig_obj[1] ;
6388
6389 if (!args) SWIG_fail;
6390 swig_obj[0] = args;
6391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6392 if (!SWIG_IsOK(res1)) {
6393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6394 }
6395 arg1 = reinterpret_cast< wxRect * >(argp1);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 result = (int)((wxRect const *)arg1)->GetHeight();
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_From_int(static_cast< int >(result));
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int arg2 ;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 int val2 ;
6416 int ecode2 = 0 ;
6417 PyObject * obj0 = 0 ;
6418 PyObject * obj1 = 0 ;
6419 char * kwnames[] = {
6420 (char *) "self",(char *) "h", NULL
6421 };
6422
6423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6425 if (!SWIG_IsOK(res1)) {
6426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6427 }
6428 arg1 = reinterpret_cast< wxRect * >(argp1);
6429 ecode2 = SWIG_AsVal_int(obj1, &val2);
6430 if (!SWIG_IsOK(ecode2)) {
6431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6432 }
6433 arg2 = static_cast< int >(val2);
6434 {
6435 PyThreadState* __tstate = wxPyBeginAllowThreads();
6436 (arg1)->SetHeight(arg2);
6437 wxPyEndAllowThreads(__tstate);
6438 if (PyErr_Occurred()) SWIG_fail;
6439 }
6440 resultobj = SWIG_Py_Void();
6441 return resultobj;
6442 fail:
6443 return NULL;
6444 }
6445
6446
6447 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6448 PyObject *resultobj = 0;
6449 wxRect *arg1 = (wxRect *) 0 ;
6450 wxPoint result;
6451 void *argp1 = 0 ;
6452 int res1 = 0 ;
6453 PyObject *swig_obj[1] ;
6454
6455 if (!args) SWIG_fail;
6456 swig_obj[0] = args;
6457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6458 if (!SWIG_IsOK(res1)) {
6459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6460 }
6461 arg1 = reinterpret_cast< wxRect * >(argp1);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 result = ((wxRect const *)arg1)->GetPosition();
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 wxPoint *arg2 = 0 ;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 wxPoint temp2 ;
6482 PyObject * obj0 = 0 ;
6483 PyObject * obj1 = 0 ;
6484 char * kwnames[] = {
6485 (char *) "self",(char *) "p", NULL
6486 };
6487
6488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6490 if (!SWIG_IsOK(res1)) {
6491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6492 }
6493 arg1 = reinterpret_cast< wxRect * >(argp1);
6494 {
6495 arg2 = &temp2;
6496 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6497 }
6498 {
6499 PyThreadState* __tstate = wxPyBeginAllowThreads();
6500 (arg1)->SetPosition((wxPoint const &)*arg2);
6501 wxPyEndAllowThreads(__tstate);
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_Py_Void();
6505 return resultobj;
6506 fail:
6507 return NULL;
6508 }
6509
6510
6511 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 wxSize result;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 PyObject *swig_obj[1] ;
6518
6519 if (!args) SWIG_fail;
6520 swig_obj[0] = args;
6521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6522 if (!SWIG_IsOK(res1)) {
6523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6524 }
6525 arg1 = reinterpret_cast< wxRect * >(argp1);
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 result = ((wxRect const *)arg1)->GetSize();
6529 wxPyEndAllowThreads(__tstate);
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = 0;
6541 wxRect *arg1 = (wxRect *) 0 ;
6542 wxSize *arg2 = 0 ;
6543 void *argp1 = 0 ;
6544 int res1 = 0 ;
6545 wxSize temp2 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char * kwnames[] = {
6549 (char *) "self",(char *) "s", NULL
6550 };
6551
6552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 {
6559 arg2 = &temp2;
6560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6561 }
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 (arg1)->SetSize((wxSize const &)*arg2);
6565 wxPyEndAllowThreads(__tstate);
6566 if (PyErr_Occurred()) SWIG_fail;
6567 }
6568 resultobj = SWIG_Py_Void();
6569 return resultobj;
6570 fail:
6571 return NULL;
6572 }
6573
6574
6575 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6576 PyObject *resultobj = 0;
6577 wxRect *arg1 = (wxRect *) 0 ;
6578 bool result;
6579 void *argp1 = 0 ;
6580 int res1 = 0 ;
6581 PyObject *swig_obj[1] ;
6582
6583 if (!args) SWIG_fail;
6584 swig_obj[0] = args;
6585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6588 }
6589 arg1 = reinterpret_cast< wxRect * >(argp1);
6590 {
6591 PyThreadState* __tstate = wxPyBeginAllowThreads();
6592 result = (bool)((wxRect const *)arg1)->IsEmpty();
6593 wxPyEndAllowThreads(__tstate);
6594 if (PyErr_Occurred()) SWIG_fail;
6595 }
6596 {
6597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6598 }
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6606 PyObject *resultobj = 0;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxPoint result;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject *swig_obj[1] ;
6612
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = ((wxRect const *)arg1)->GetTopLeft();
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxPoint *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 wxPoint temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "p", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 resultobj = SWIG_Py_Void();
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxRect *arg1 = (wxRect *) 0 ;
6672 wxPoint result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = ((wxRect const *)arg1)->GetBottomRight();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj = 0;
6699 wxRect *arg1 = (wxRect *) 0 ;
6700 wxPoint *arg2 = 0 ;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 wxPoint temp2 ;
6704 PyObject * obj0 = 0 ;
6705 PyObject * obj1 = 0 ;
6706 char * kwnames[] = {
6707 (char *) "self",(char *) "p", NULL
6708 };
6709
6710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6714 }
6715 arg1 = reinterpret_cast< wxRect * >(argp1);
6716 {
6717 arg2 = &temp2;
6718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6719 }
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6723 wxPyEndAllowThreads(__tstate);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_Py_Void();
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 wxRect *arg1 = (wxRect *) 0 ;
6736 int result;
6737 void *argp1 = 0 ;
6738 int res1 = 0 ;
6739 PyObject *swig_obj[1] ;
6740
6741 if (!args) SWIG_fail;
6742 swig_obj[0] = args;
6743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 PyThreadState* __tstate = wxPyBeginAllowThreads();
6750 result = (int)((wxRect const *)arg1)->GetLeft();
6751 wxPyEndAllowThreads(__tstate);
6752 if (PyErr_Occurred()) SWIG_fail;
6753 }
6754 resultobj = SWIG_From_int(static_cast< int >(result));
6755 return resultobj;
6756 fail:
6757 return NULL;
6758 }
6759
6760
6761 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6762 PyObject *resultobj = 0;
6763 wxRect *arg1 = (wxRect *) 0 ;
6764 int result;
6765 void *argp1 = 0 ;
6766 int res1 = 0 ;
6767 PyObject *swig_obj[1] ;
6768
6769 if (!args) SWIG_fail;
6770 swig_obj[0] = args;
6771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6772 if (!SWIG_IsOK(res1)) {
6773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6774 }
6775 arg1 = reinterpret_cast< wxRect * >(argp1);
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 result = (int)((wxRect const *)arg1)->GetTop();
6779 wxPyEndAllowThreads(__tstate);
6780 if (PyErr_Occurred()) SWIG_fail;
6781 }
6782 resultobj = SWIG_From_int(static_cast< int >(result));
6783 return resultobj;
6784 fail:
6785 return NULL;
6786 }
6787
6788
6789 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6790 PyObject *resultobj = 0;
6791 wxRect *arg1 = (wxRect *) 0 ;
6792 int result;
6793 void *argp1 = 0 ;
6794 int res1 = 0 ;
6795 PyObject *swig_obj[1] ;
6796
6797 if (!args) SWIG_fail;
6798 swig_obj[0] = args;
6799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6800 if (!SWIG_IsOK(res1)) {
6801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6802 }
6803 arg1 = reinterpret_cast< wxRect * >(argp1);
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (int)((wxRect const *)arg1)->GetBottom();
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 resultobj = SWIG_From_int(static_cast< int >(result));
6811 return resultobj;
6812 fail:
6813 return NULL;
6814 }
6815
6816
6817 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6818 PyObject *resultobj = 0;
6819 wxRect *arg1 = (wxRect *) 0 ;
6820 int result;
6821 void *argp1 = 0 ;
6822 int res1 = 0 ;
6823 PyObject *swig_obj[1] ;
6824
6825 if (!args) SWIG_fail;
6826 swig_obj[0] = args;
6827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6828 if (!SWIG_IsOK(res1)) {
6829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6830 }
6831 arg1 = reinterpret_cast< wxRect * >(argp1);
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (int)((wxRect const *)arg1)->GetRight();
6835 wxPyEndAllowThreads(__tstate);
6836 if (PyErr_Occurred()) SWIG_fail;
6837 }
6838 resultobj = SWIG_From_int(static_cast< int >(result));
6839 return resultobj;
6840 fail:
6841 return NULL;
6842 }
6843
6844
6845 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6846 PyObject *resultobj = 0;
6847 wxRect *arg1 = (wxRect *) 0 ;
6848 int arg2 ;
6849 void *argp1 = 0 ;
6850 int res1 = 0 ;
6851 int val2 ;
6852 int ecode2 = 0 ;
6853 PyObject * obj0 = 0 ;
6854 PyObject * obj1 = 0 ;
6855 char * kwnames[] = {
6856 (char *) "self",(char *) "left", NULL
6857 };
6858
6859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6861 if (!SWIG_IsOK(res1)) {
6862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6863 }
6864 arg1 = reinterpret_cast< wxRect * >(argp1);
6865 ecode2 = SWIG_AsVal_int(obj1, &val2);
6866 if (!SWIG_IsOK(ecode2)) {
6867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6868 }
6869 arg2 = static_cast< int >(val2);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 (arg1)->SetLeft(arg2);
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_Py_Void();
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int arg2 ;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 int val2 ;
6890 int ecode2 = 0 ;
6891 PyObject * obj0 = 0 ;
6892 PyObject * obj1 = 0 ;
6893 char * kwnames[] = {
6894 (char *) "self",(char *) "right", NULL
6895 };
6896
6897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 ecode2 = SWIG_AsVal_int(obj1, &val2);
6904 if (!SWIG_IsOK(ecode2)) {
6905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6906 }
6907 arg2 = static_cast< int >(val2);
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->SetRight(arg2);
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_Py_Void();
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 int arg2 ;
6925 void *argp1 = 0 ;
6926 int res1 = 0 ;
6927 int val2 ;
6928 int ecode2 = 0 ;
6929 PyObject * obj0 = 0 ;
6930 PyObject * obj1 = 0 ;
6931 char * kwnames[] = {
6932 (char *) "self",(char *) "top", NULL
6933 };
6934
6935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6937 if (!SWIG_IsOK(res1)) {
6938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6939 }
6940 arg1 = reinterpret_cast< wxRect * >(argp1);
6941 ecode2 = SWIG_AsVal_int(obj1, &val2);
6942 if (!SWIG_IsOK(ecode2)) {
6943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6944 }
6945 arg2 = static_cast< int >(val2);
6946 {
6947 PyThreadState* __tstate = wxPyBeginAllowThreads();
6948 (arg1)->SetTop(arg2);
6949 wxPyEndAllowThreads(__tstate);
6950 if (PyErr_Occurred()) SWIG_fail;
6951 }
6952 resultobj = SWIG_Py_Void();
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = 0;
6961 wxRect *arg1 = (wxRect *) 0 ;
6962 int arg2 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 int val2 ;
6966 int ecode2 = 0 ;
6967 PyObject * obj0 = 0 ;
6968 PyObject * obj1 = 0 ;
6969 char * kwnames[] = {
6970 (char *) "self",(char *) "bottom", NULL
6971 };
6972
6973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 ecode2 = SWIG_AsVal_int(obj1, &val2);
6980 if (!SWIG_IsOK(ecode2)) {
6981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6982 }
6983 arg2 = static_cast< int >(val2);
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 (arg1)->SetBottom(arg2);
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 resultobj = SWIG_Py_Void();
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6998 PyObject *resultobj = 0;
6999 wxRect *arg1 = (wxRect *) 0 ;
7000 int arg2 ;
7001 int arg3 ;
7002 wxRect *result = 0 ;
7003 void *argp1 = 0 ;
7004 int res1 = 0 ;
7005 int val2 ;
7006 int ecode2 = 0 ;
7007 int val3 ;
7008 int ecode3 = 0 ;
7009 PyObject * obj0 = 0 ;
7010 PyObject * obj1 = 0 ;
7011 PyObject * obj2 = 0 ;
7012 char * kwnames[] = {
7013 (char *) "self",(char *) "dx",(char *) "dy", NULL
7014 };
7015
7016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7018 if (!SWIG_IsOK(res1)) {
7019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7020 }
7021 arg1 = reinterpret_cast< wxRect * >(argp1);
7022 ecode2 = SWIG_AsVal_int(obj1, &val2);
7023 if (!SWIG_IsOK(ecode2)) {
7024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7025 }
7026 arg2 = static_cast< int >(val2);
7027 ecode3 = SWIG_AsVal_int(obj2, &val3);
7028 if (!SWIG_IsOK(ecode3)) {
7029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7030 }
7031 arg3 = static_cast< int >(val3);
7032 {
7033 PyThreadState* __tstate = wxPyBeginAllowThreads();
7034 {
7035 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7036 result = (wxRect *) &_result_ref;
7037 }
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj = 0;
7050 wxRect *arg1 = (wxRect *) 0 ;
7051 int arg2 ;
7052 int arg3 ;
7053 wxRect *result = 0 ;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 int val2 ;
7057 int ecode2 = 0 ;
7058 int val3 ;
7059 int ecode3 = 0 ;
7060 PyObject * obj0 = 0 ;
7061 PyObject * obj1 = 0 ;
7062 PyObject * obj2 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "self",(char *) "dx",(char *) "dy", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7069 if (!SWIG_IsOK(res1)) {
7070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7071 }
7072 arg1 = reinterpret_cast< wxRect * >(argp1);
7073 ecode2 = SWIG_AsVal_int(obj1, &val2);
7074 if (!SWIG_IsOK(ecode2)) {
7075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7076 }
7077 arg2 = static_cast< int >(val2);
7078 ecode3 = SWIG_AsVal_int(obj2, &val3);
7079 if (!SWIG_IsOK(ecode3)) {
7080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7081 }
7082 arg3 = static_cast< int >(val3);
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 {
7086 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7087 result = (wxRect *) &_result_ref;
7088 }
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj = 0;
7101 wxRect *arg1 = (wxRect *) 0 ;
7102 int arg2 ;
7103 int arg3 ;
7104 void *argp1 = 0 ;
7105 int res1 = 0 ;
7106 int val2 ;
7107 int ecode2 = 0 ;
7108 int val3 ;
7109 int ecode3 = 0 ;
7110 PyObject * obj0 = 0 ;
7111 PyObject * obj1 = 0 ;
7112 PyObject * obj2 = 0 ;
7113 char * kwnames[] = {
7114 (char *) "self",(char *) "dx",(char *) "dy", NULL
7115 };
7116
7117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 ecode2 = SWIG_AsVal_int(obj1, &val2);
7124 if (!SWIG_IsOK(ecode2)) {
7125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7126 }
7127 arg2 = static_cast< int >(val2);
7128 ecode3 = SWIG_AsVal_int(obj2, &val3);
7129 if (!SWIG_IsOK(ecode3)) {
7130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7131 }
7132 arg3 = static_cast< int >(val3);
7133 {
7134 PyThreadState* __tstate = wxPyBeginAllowThreads();
7135 (arg1)->Offset(arg2,arg3);
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 resultobj = SWIG_Py_Void();
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj = 0;
7148 wxRect *arg1 = (wxRect *) 0 ;
7149 wxPoint *arg2 = 0 ;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 wxPoint temp2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char * kwnames[] = {
7156 (char *) "self",(char *) "pt", NULL
7157 };
7158
7159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7161 if (!SWIG_IsOK(res1)) {
7162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7163 }
7164 arg1 = reinterpret_cast< wxRect * >(argp1);
7165 {
7166 arg2 = &temp2;
7167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7168 }
7169 {
7170 PyThreadState* __tstate = wxPyBeginAllowThreads();
7171 (arg1)->Offset((wxPoint const &)*arg2);
7172 wxPyEndAllowThreads(__tstate);
7173 if (PyErr_Occurred()) SWIG_fail;
7174 }
7175 resultobj = SWIG_Py_Void();
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj = 0;
7184 wxRect *arg1 = (wxRect *) 0 ;
7185 wxRect *arg2 = 0 ;
7186 wxRect result;
7187 void *argp1 = 0 ;
7188 int res1 = 0 ;
7189 wxRect temp2 ;
7190 PyObject * obj0 = 0 ;
7191 PyObject * obj1 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "rect", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 {
7203 arg2 = &temp2;
7204 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7205 }
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 result = (arg1)->Intersect((wxRect const &)*arg2);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxRect *arg1 = (wxRect *) 0 ;
7222 wxRect *arg2 = 0 ;
7223 wxRect result;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 wxRect temp2 ;
7227 PyObject * obj0 = 0 ;
7228 PyObject * obj1 = 0 ;
7229 char * kwnames[] = {
7230 (char *) "self",(char *) "rect", NULL
7231 };
7232
7233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7235 if (!SWIG_IsOK(res1)) {
7236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7237 }
7238 arg1 = reinterpret_cast< wxRect * >(argp1);
7239 {
7240 arg2 = &temp2;
7241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7242 }
7243 {
7244 PyThreadState* __tstate = wxPyBeginAllowThreads();
7245 result = (arg1)->Union((wxRect const &)*arg2);
7246 wxPyEndAllowThreads(__tstate);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxRect *arg1 = (wxRect *) 0 ;
7259 wxRect *arg2 = 0 ;
7260 wxRect result;
7261 void *argp1 = 0 ;
7262 int res1 = 0 ;
7263 wxRect temp2 ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 char * kwnames[] = {
7267 (char *) "self",(char *) "rect", NULL
7268 };
7269
7270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7272 if (!SWIG_IsOK(res1)) {
7273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7274 }
7275 arg1 = reinterpret_cast< wxRect * >(argp1);
7276 {
7277 arg2 = &temp2;
7278 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7279 }
7280 {
7281 PyThreadState* __tstate = wxPyBeginAllowThreads();
7282 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7283 wxPyEndAllowThreads(__tstate);
7284 if (PyErr_Occurred()) SWIG_fail;
7285 }
7286 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7287 return resultobj;
7288 fail:
7289 return NULL;
7290 }
7291
7292
7293 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7294 PyObject *resultobj = 0;
7295 wxRect *arg1 = (wxRect *) 0 ;
7296 wxRect *arg2 = 0 ;
7297 wxRect *result = 0 ;
7298 void *argp1 = 0 ;
7299 int res1 = 0 ;
7300 wxRect temp2 ;
7301 PyObject * obj0 = 0 ;
7302 PyObject * obj1 = 0 ;
7303 char * kwnames[] = {
7304 (char *) "self",(char *) "rect", NULL
7305 };
7306
7307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7309 if (!SWIG_IsOK(res1)) {
7310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7311 }
7312 arg1 = reinterpret_cast< wxRect * >(argp1);
7313 {
7314 arg2 = &temp2;
7315 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 {
7320 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7321 result = (wxRect *) &_result_ref;
7322 }
7323 wxPyEndAllowThreads(__tstate);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj = 0;
7335 wxRect *arg1 = (wxRect *) 0 ;
7336 PyObject *arg2 = (PyObject *) 0 ;
7337 bool result;
7338 void *argp1 = 0 ;
7339 int res1 = 0 ;
7340 PyObject * obj0 = 0 ;
7341 PyObject * obj1 = 0 ;
7342 char * kwnames[] = {
7343 (char *) "self",(char *) "other", NULL
7344 };
7345
7346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7350 }
7351 arg1 = reinterpret_cast< wxRect * >(argp1);
7352 arg2 = obj1;
7353 {
7354 result = (bool)wxRect___eq__(arg1,arg2);
7355 if (PyErr_Occurred()) SWIG_fail;
7356 }
7357 {
7358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7359 }
7360 return resultobj;
7361 fail:
7362 return NULL;
7363 }
7364
7365
7366 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj = 0;
7368 wxRect *arg1 = (wxRect *) 0 ;
7369 PyObject *arg2 = (PyObject *) 0 ;
7370 bool result;
7371 void *argp1 = 0 ;
7372 int res1 = 0 ;
7373 PyObject * obj0 = 0 ;
7374 PyObject * obj1 = 0 ;
7375 char * kwnames[] = {
7376 (char *) "self",(char *) "other", NULL
7377 };
7378
7379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7381 if (!SWIG_IsOK(res1)) {
7382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7383 }
7384 arg1 = reinterpret_cast< wxRect * >(argp1);
7385 arg2 = obj1;
7386 {
7387 result = (bool)wxRect___ne__(arg1,arg2);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 {
7391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7392 }
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 int arg2 ;
7403 int arg3 ;
7404 bool result;
7405 void *argp1 = 0 ;
7406 int res1 = 0 ;
7407 int val2 ;
7408 int ecode2 = 0 ;
7409 int val3 ;
7410 int ecode3 = 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 char * kwnames[] = {
7415 (char *) "self",(char *) "x",(char *) "y", NULL
7416 };
7417
7418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7422 }
7423 arg1 = reinterpret_cast< wxRect * >(argp1);
7424 ecode2 = SWIG_AsVal_int(obj1, &val2);
7425 if (!SWIG_IsOK(ecode2)) {
7426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7427 }
7428 arg2 = static_cast< int >(val2);
7429 ecode3 = SWIG_AsVal_int(obj2, &val3);
7430 if (!SWIG_IsOK(ecode3)) {
7431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7432 }
7433 arg3 = static_cast< int >(val3);
7434 {
7435 PyThreadState* __tstate = wxPyBeginAllowThreads();
7436 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7437 wxPyEndAllowThreads(__tstate);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 {
7441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7442 }
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxPoint *arg2 = 0 ;
7453 bool result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxPoint temp2 ;
7457 PyObject * obj0 = 0 ;
7458 PyObject * obj1 = 0 ;
7459 char * kwnames[] = {
7460 (char *) "self",(char *) "pt", NULL
7461 };
7462
7463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7465 if (!SWIG_IsOK(res1)) {
7466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7467 }
7468 arg1 = reinterpret_cast< wxRect * >(argp1);
7469 {
7470 arg2 = &temp2;
7471 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7472 }
7473 {
7474 PyThreadState* __tstate = wxPyBeginAllowThreads();
7475 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 {
7480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7481 }
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7489 PyObject *resultobj = 0;
7490 wxRect *arg1 = (wxRect *) 0 ;
7491 wxRect *arg2 = 0 ;
7492 bool result;
7493 void *argp1 = 0 ;
7494 int res1 = 0 ;
7495 wxRect temp2 ;
7496 PyObject * obj0 = 0 ;
7497 PyObject * obj1 = 0 ;
7498 char * kwnames[] = {
7499 (char *) "self",(char *) "rect", NULL
7500 };
7501
7502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7504 if (!SWIG_IsOK(res1)) {
7505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7506 }
7507 arg1 = reinterpret_cast< wxRect * >(argp1);
7508 {
7509 arg2 = &temp2;
7510 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7511 }
7512 {
7513 PyThreadState* __tstate = wxPyBeginAllowThreads();
7514 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7515 wxPyEndAllowThreads(__tstate);
7516 if (PyErr_Occurred()) SWIG_fail;
7517 }
7518 {
7519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7520 }
7521 return resultobj;
7522 fail:
7523 return NULL;
7524 }
7525
7526
7527 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7528 PyObject *resultobj = 0;
7529 wxRect *arg1 = (wxRect *) 0 ;
7530 wxRect *arg2 = 0 ;
7531 int arg3 = (int) wxBOTH ;
7532 wxRect result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 wxRect temp2 ;
7536 int val3 ;
7537 int ecode3 = 0 ;
7538 PyObject * obj0 = 0 ;
7539 PyObject * obj1 = 0 ;
7540 PyObject * obj2 = 0 ;
7541 char * kwnames[] = {
7542 (char *) "self",(char *) "r",(char *) "dir", NULL
7543 };
7544
7545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7547 if (!SWIG_IsOK(res1)) {
7548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7549 }
7550 arg1 = reinterpret_cast< wxRect * >(argp1);
7551 {
7552 arg2 = &temp2;
7553 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7554 }
7555 if (obj2) {
7556 ecode3 = SWIG_AsVal_int(obj2, &val3);
7557 if (!SWIG_IsOK(ecode3)) {
7558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7559 }
7560 arg3 = static_cast< int >(val3);
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7576 PyObject *resultobj = 0;
7577 wxRect *arg1 = (wxRect *) 0 ;
7578 int arg2 ;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 int val2 ;
7582 int ecode2 = 0 ;
7583 PyObject *swig_obj[2] ;
7584
7585 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7587 if (!SWIG_IsOK(res1)) {
7588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7589 }
7590 arg1 = reinterpret_cast< wxRect * >(argp1);
7591 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7592 if (!SWIG_IsOK(ecode2)) {
7593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7594 }
7595 arg2 = static_cast< int >(val2);
7596 if (arg1) (arg1)->x = arg2;
7597
7598 resultobj = SWIG_Py_Void();
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7606 PyObject *resultobj = 0;
7607 wxRect *arg1 = (wxRect *) 0 ;
7608 int result;
7609 void *argp1 = 0 ;
7610 int res1 = 0 ;
7611 PyObject *swig_obj[1] ;
7612
7613 if (!args) SWIG_fail;
7614 swig_obj[0] = args;
7615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7616 if (!SWIG_IsOK(res1)) {
7617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7618 }
7619 arg1 = reinterpret_cast< wxRect * >(argp1);
7620 result = (int) ((arg1)->x);
7621 resultobj = SWIG_From_int(static_cast< int >(result));
7622 return resultobj;
7623 fail:
7624 return NULL;
7625 }
7626
7627
7628 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7629 PyObject *resultobj = 0;
7630 wxRect *arg1 = (wxRect *) 0 ;
7631 int arg2 ;
7632 void *argp1 = 0 ;
7633 int res1 = 0 ;
7634 int val2 ;
7635 int ecode2 = 0 ;
7636 PyObject *swig_obj[2] ;
7637
7638 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7645 if (!SWIG_IsOK(ecode2)) {
7646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7647 }
7648 arg2 = static_cast< int >(val2);
7649 if (arg1) (arg1)->y = arg2;
7650
7651 resultobj = SWIG_Py_Void();
7652 return resultobj;
7653 fail:
7654 return NULL;
7655 }
7656
7657
7658 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7659 PyObject *resultobj = 0;
7660 wxRect *arg1 = (wxRect *) 0 ;
7661 int result;
7662 void *argp1 = 0 ;
7663 int res1 = 0 ;
7664 PyObject *swig_obj[1] ;
7665
7666 if (!args) SWIG_fail;
7667 swig_obj[0] = args;
7668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7669 if (!SWIG_IsOK(res1)) {
7670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7671 }
7672 arg1 = reinterpret_cast< wxRect * >(argp1);
7673 result = (int) ((arg1)->y);
7674 resultobj = SWIG_From_int(static_cast< int >(result));
7675 return resultobj;
7676 fail:
7677 return NULL;
7678 }
7679
7680
7681 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 PyObject *resultobj = 0;
7683 wxRect *arg1 = (wxRect *) 0 ;
7684 int arg2 ;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 int val2 ;
7688 int ecode2 = 0 ;
7689 PyObject *swig_obj[2] ;
7690
7691 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7693 if (!SWIG_IsOK(res1)) {
7694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7695 }
7696 arg1 = reinterpret_cast< wxRect * >(argp1);
7697 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7698 if (!SWIG_IsOK(ecode2)) {
7699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7700 }
7701 arg2 = static_cast< int >(val2);
7702 if (arg1) (arg1)->width = arg2;
7703
7704 resultobj = SWIG_Py_Void();
7705 return resultobj;
7706 fail:
7707 return NULL;
7708 }
7709
7710
7711 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7712 PyObject *resultobj = 0;
7713 wxRect *arg1 = (wxRect *) 0 ;
7714 int result;
7715 void *argp1 = 0 ;
7716 int res1 = 0 ;
7717 PyObject *swig_obj[1] ;
7718
7719 if (!args) SWIG_fail;
7720 swig_obj[0] = args;
7721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7724 }
7725 arg1 = reinterpret_cast< wxRect * >(argp1);
7726 result = (int) ((arg1)->width);
7727 resultobj = SWIG_From_int(static_cast< int >(result));
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7735 PyObject *resultobj = 0;
7736 wxRect *arg1 = (wxRect *) 0 ;
7737 int arg2 ;
7738 void *argp1 = 0 ;
7739 int res1 = 0 ;
7740 int val2 ;
7741 int ecode2 = 0 ;
7742 PyObject *swig_obj[2] ;
7743
7744 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7746 if (!SWIG_IsOK(res1)) {
7747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7748 }
7749 arg1 = reinterpret_cast< wxRect * >(argp1);
7750 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7751 if (!SWIG_IsOK(ecode2)) {
7752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7753 }
7754 arg2 = static_cast< int >(val2);
7755 if (arg1) (arg1)->height = arg2;
7756
7757 resultobj = SWIG_Py_Void();
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7765 PyObject *resultobj = 0;
7766 wxRect *arg1 = (wxRect *) 0 ;
7767 int result;
7768 void *argp1 = 0 ;
7769 int res1 = 0 ;
7770 PyObject *swig_obj[1] ;
7771
7772 if (!args) SWIG_fail;
7773 swig_obj[0] = args;
7774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7775 if (!SWIG_IsOK(res1)) {
7776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7777 }
7778 arg1 = reinterpret_cast< wxRect * >(argp1);
7779 result = (int) ((arg1)->height);
7780 resultobj = SWIG_From_int(static_cast< int >(result));
7781 return resultobj;
7782 fail:
7783 return NULL;
7784 }
7785
7786
7787 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7788 PyObject *resultobj = 0;
7789 wxRect *arg1 = (wxRect *) 0 ;
7790 int arg2 = (int) 0 ;
7791 int arg3 = (int) 0 ;
7792 int arg4 = (int) 0 ;
7793 int arg5 = (int) 0 ;
7794 void *argp1 = 0 ;
7795 int res1 = 0 ;
7796 int val2 ;
7797 int ecode2 = 0 ;
7798 int val3 ;
7799 int ecode3 = 0 ;
7800 int val4 ;
7801 int ecode4 = 0 ;
7802 int val5 ;
7803 int ecode5 = 0 ;
7804 PyObject * obj0 = 0 ;
7805 PyObject * obj1 = 0 ;
7806 PyObject * obj2 = 0 ;
7807 PyObject * obj3 = 0 ;
7808 PyObject * obj4 = 0 ;
7809 char * kwnames[] = {
7810 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7811 };
7812
7813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7815 if (!SWIG_IsOK(res1)) {
7816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7817 }
7818 arg1 = reinterpret_cast< wxRect * >(argp1);
7819 if (obj1) {
7820 ecode2 = SWIG_AsVal_int(obj1, &val2);
7821 if (!SWIG_IsOK(ecode2)) {
7822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7823 }
7824 arg2 = static_cast< int >(val2);
7825 }
7826 if (obj2) {
7827 ecode3 = SWIG_AsVal_int(obj2, &val3);
7828 if (!SWIG_IsOK(ecode3)) {
7829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7830 }
7831 arg3 = static_cast< int >(val3);
7832 }
7833 if (obj3) {
7834 ecode4 = SWIG_AsVal_int(obj3, &val4);
7835 if (!SWIG_IsOK(ecode4)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7837 }
7838 arg4 = static_cast< int >(val4);
7839 }
7840 if (obj4) {
7841 ecode5 = SWIG_AsVal_int(obj4, &val5);
7842 if (!SWIG_IsOK(ecode5)) {
7843 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7844 }
7845 arg5 = static_cast< int >(val5);
7846 }
7847 {
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_Py_Void();
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7861 PyObject *resultobj = 0;
7862 wxRect *arg1 = (wxRect *) 0 ;
7863 PyObject *result = 0 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 PyObject *swig_obj[1] ;
7867
7868 if (!args) SWIG_fail;
7869 swig_obj[0] = args;
7870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7871 if (!SWIG_IsOK(res1)) {
7872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7873 }
7874 arg1 = reinterpret_cast< wxRect * >(argp1);
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 result = (PyObject *)wxRect_Get(arg1);
7878 wxPyEndAllowThreads(__tstate);
7879 if (PyErr_Occurred()) SWIG_fail;
7880 }
7881 resultobj = result;
7882 return resultobj;
7883 fail:
7884 return NULL;
7885 }
7886
7887
7888 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7889 PyObject *obj;
7890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7891 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7892 return SWIG_Py_Void();
7893 }
7894
7895 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7896 return SWIG_Python_InitShadowInstance(args);
7897 }
7898
7899 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7900 PyObject *resultobj = 0;
7901 wxRect *arg1 = (wxRect *) 0 ;
7902 wxRect *arg2 = (wxRect *) 0 ;
7903 PyObject *result = 0 ;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 void *argp2 = 0 ;
7907 int res2 = 0 ;
7908 PyObject * obj0 = 0 ;
7909 PyObject * obj1 = 0 ;
7910 char * kwnames[] = {
7911 (char *) "r1",(char *) "r2", NULL
7912 };
7913
7914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7916 if (!SWIG_IsOK(res1)) {
7917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7918 }
7919 arg1 = reinterpret_cast< wxRect * >(argp1);
7920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7921 if (!SWIG_IsOK(res2)) {
7922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7923 }
7924 arg2 = reinterpret_cast< wxRect * >(argp2);
7925 {
7926 if (!wxPyCheckForApp()) SWIG_fail;
7927 PyThreadState* __tstate = wxPyBeginAllowThreads();
7928 result = (PyObject *)wxIntersectRect(arg1,arg2);
7929 wxPyEndAllowThreads(__tstate);
7930 if (PyErr_Occurred()) SWIG_fail;
7931 }
7932 resultobj = result;
7933 return resultobj;
7934 fail:
7935 return NULL;
7936 }
7937
7938
7939 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7940 PyObject *resultobj = 0;
7941 double arg1 = (double) 0.0 ;
7942 double arg2 = (double) 0.0 ;
7943 wxPoint2D *result = 0 ;
7944 double val1 ;
7945 int ecode1 = 0 ;
7946 double val2 ;
7947 int ecode2 = 0 ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 char * kwnames[] = {
7951 (char *) "x",(char *) "y", NULL
7952 };
7953
7954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7955 if (obj0) {
7956 ecode1 = SWIG_AsVal_double(obj0, &val1);
7957 if (!SWIG_IsOK(ecode1)) {
7958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7959 }
7960 arg1 = static_cast< double >(val1);
7961 }
7962 if (obj1) {
7963 ecode2 = SWIG_AsVal_double(obj1, &val2);
7964 if (!SWIG_IsOK(ecode2)) {
7965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7966 }
7967 arg2 = static_cast< double >(val2);
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7972 wxPyEndAllowThreads(__tstate);
7973 if (PyErr_Occurred()) SWIG_fail;
7974 }
7975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7976 return resultobj;
7977 fail:
7978 return NULL;
7979 }
7980
7981
7982 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7983 PyObject *resultobj = 0;
7984 wxPoint2D *arg1 = 0 ;
7985 wxPoint2D *result = 0 ;
7986 wxPoint2D temp1 ;
7987 PyObject * obj0 = 0 ;
7988 char * kwnames[] = {
7989 (char *) "pt", NULL
7990 };
7991
7992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7993 {
7994 arg1 = &temp1;
7995 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7996 }
7997 {
7998 PyThreadState* __tstate = wxPyBeginAllowThreads();
7999 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8000 wxPyEndAllowThreads(__tstate);
8001 if (PyErr_Occurred()) SWIG_fail;
8002 }
8003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8011 PyObject *resultobj = 0;
8012 wxPoint *arg1 = 0 ;
8013 wxPoint2D *result = 0 ;
8014 wxPoint temp1 ;
8015 PyObject * obj0 = 0 ;
8016 char * kwnames[] = {
8017 (char *) "pt", NULL
8018 };
8019
8020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8021 {
8022 arg1 = &temp1;
8023 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8024 }
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8028 wxPyEndAllowThreads(__tstate);
8029 if (PyErr_Occurred()) SWIG_fail;
8030 }
8031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8039 PyObject *resultobj = 0;
8040 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8041 int *arg2 = (int *) 0 ;
8042 int *arg3 = (int *) 0 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int temp2 ;
8046 int res2 = SWIG_TMPOBJ ;
8047 int temp3 ;
8048 int res3 = SWIG_TMPOBJ ;
8049 PyObject *swig_obj[1] ;
8050
8051 arg2 = &temp2;
8052 arg3 = &temp3;
8053 if (!args) SWIG_fail;
8054 swig_obj[0] = args;
8055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8056 if (!SWIG_IsOK(res1)) {
8057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8058 }
8059 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8060 {
8061 PyThreadState* __tstate = wxPyBeginAllowThreads();
8062 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8063 wxPyEndAllowThreads(__tstate);
8064 if (PyErr_Occurred()) SWIG_fail;
8065 }
8066 resultobj = SWIG_Py_Void();
8067 if (SWIG_IsTmpObj(res2)) {
8068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8069 } else {
8070 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8072 }
8073 if (SWIG_IsTmpObj(res3)) {
8074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8075 } else {
8076 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8078 }
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8086 PyObject *resultobj = 0;
8087 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8088 int *arg2 = (int *) 0 ;
8089 int *arg3 = (int *) 0 ;
8090 void *argp1 = 0 ;
8091 int res1 = 0 ;
8092 int temp2 ;
8093 int res2 = SWIG_TMPOBJ ;
8094 int temp3 ;
8095 int res3 = SWIG_TMPOBJ ;
8096 PyObject *swig_obj[1] ;
8097
8098 arg2 = &temp2;
8099 arg3 = &temp3;
8100 if (!args) SWIG_fail;
8101 swig_obj[0] = args;
8102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8105 }
8106 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8107 {
8108 PyThreadState* __tstate = wxPyBeginAllowThreads();
8109 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8110 wxPyEndAllowThreads(__tstate);
8111 if (PyErr_Occurred()) SWIG_fail;
8112 }
8113 resultobj = SWIG_Py_Void();
8114 if (SWIG_IsTmpObj(res2)) {
8115 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8116 } else {
8117 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8118 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8119 }
8120 if (SWIG_IsTmpObj(res3)) {
8121 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8122 } else {
8123 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8124 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8125 }
8126 return resultobj;
8127 fail:
8128 return NULL;
8129 }
8130
8131
8132 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8133 PyObject *resultobj = 0;
8134 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8135 double result;
8136 void *argp1 = 0 ;
8137 int res1 = 0 ;
8138 PyObject *swig_obj[1] ;
8139
8140 if (!args) SWIG_fail;
8141 swig_obj[0] = args;
8142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8143 if (!SWIG_IsOK(res1)) {
8144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8145 }
8146 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8147 {
8148 PyThreadState* __tstate = wxPyBeginAllowThreads();
8149 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8150 wxPyEndAllowThreads(__tstate);
8151 if (PyErr_Occurred()) SWIG_fail;
8152 }
8153 resultobj = SWIG_From_double(static_cast< double >(result));
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8161 PyObject *resultobj = 0;
8162 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8163 double result;
8164 void *argp1 = 0 ;
8165 int res1 = 0 ;
8166 PyObject *swig_obj[1] ;
8167
8168 if (!args) SWIG_fail;
8169 swig_obj[0] = args;
8170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8171 if (!SWIG_IsOK(res1)) {
8172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8173 }
8174 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8178 wxPyEndAllowThreads(__tstate);
8179 if (PyErr_Occurred()) SWIG_fail;
8180 }
8181 resultobj = SWIG_From_double(static_cast< double >(result));
8182 return resultobj;
8183 fail:
8184 return NULL;
8185 }
8186
8187
8188 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8189 PyObject *resultobj = 0;
8190 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8191 double arg2 ;
8192 void *argp1 = 0 ;
8193 int res1 = 0 ;
8194 double val2 ;
8195 int ecode2 = 0 ;
8196 PyObject * obj0 = 0 ;
8197 PyObject * obj1 = 0 ;
8198 char * kwnames[] = {
8199 (char *) "self",(char *) "length", NULL
8200 };
8201
8202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8204 if (!SWIG_IsOK(res1)) {
8205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8206 }
8207 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8208 ecode2 = SWIG_AsVal_double(obj1, &val2);
8209 if (!SWIG_IsOK(ecode2)) {
8210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8211 }
8212 arg2 = static_cast< double >(val2);
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 (arg1)->SetVectorLength(arg2);
8216 wxPyEndAllowThreads(__tstate);
8217 if (PyErr_Occurred()) SWIG_fail;
8218 }
8219 resultobj = SWIG_Py_Void();
8220 return resultobj;
8221 fail:
8222 return NULL;
8223 }
8224
8225
8226 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8227 PyObject *resultobj = 0;
8228 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8229 double arg2 ;
8230 void *argp1 = 0 ;
8231 int res1 = 0 ;
8232 double val2 ;
8233 int ecode2 = 0 ;
8234 PyObject * obj0 = 0 ;
8235 PyObject * obj1 = 0 ;
8236 char * kwnames[] = {
8237 (char *) "self",(char *) "degrees", NULL
8238 };
8239
8240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8242 if (!SWIG_IsOK(res1)) {
8243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8244 }
8245 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8246 ecode2 = SWIG_AsVal_double(obj1, &val2);
8247 if (!SWIG_IsOK(ecode2)) {
8248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8249 }
8250 arg2 = static_cast< double >(val2);
8251 {
8252 PyThreadState* __tstate = wxPyBeginAllowThreads();
8253 (arg1)->SetVectorAngle(arg2);
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_Py_Void();
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj = 0;
8266 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8267 wxPoint2D *arg2 = 0 ;
8268 double result;
8269 void *argp1 = 0 ;
8270 int res1 = 0 ;
8271 wxPoint2D temp2 ;
8272 PyObject * obj0 = 0 ;
8273 PyObject * obj1 = 0 ;
8274 char * kwnames[] = {
8275 (char *) "self",(char *) "pt", NULL
8276 };
8277
8278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8280 if (!SWIG_IsOK(res1)) {
8281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8282 }
8283 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8284 {
8285 arg2 = &temp2;
8286 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8287 }
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = SWIG_From_double(static_cast< double >(result));
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8304 wxPoint2D *arg2 = 0 ;
8305 double result;
8306 void *argp1 = 0 ;
8307 int res1 = 0 ;
8308 wxPoint2D temp2 ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 char * kwnames[] = {
8312 (char *) "self",(char *) "pt", NULL
8313 };
8314
8315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8317 if (!SWIG_IsOK(res1)) {
8318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8319 }
8320 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8321 {
8322 arg2 = &temp2;
8323 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8324 }
8325 {
8326 PyThreadState* __tstate = wxPyBeginAllowThreads();
8327 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8328 wxPyEndAllowThreads(__tstate);
8329 if (PyErr_Occurred()) SWIG_fail;
8330 }
8331 resultobj = SWIG_From_double(static_cast< double >(result));
8332 return resultobj;
8333 fail:
8334 return NULL;
8335 }
8336
8337
8338 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8339 PyObject *resultobj = 0;
8340 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8341 wxPoint2D *arg2 = 0 ;
8342 double result;
8343 void *argp1 = 0 ;
8344 int res1 = 0 ;
8345 wxPoint2D temp2 ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 char * kwnames[] = {
8349 (char *) "self",(char *) "vec", NULL
8350 };
8351
8352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8354 if (!SWIG_IsOK(res1)) {
8355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8356 }
8357 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8358 {
8359 arg2 = &temp2;
8360 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8361 }
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8365 wxPyEndAllowThreads(__tstate);
8366 if (PyErr_Occurred()) SWIG_fail;
8367 }
8368 resultobj = SWIG_From_double(static_cast< double >(result));
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj = 0;
8377 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8378 wxPoint2D *arg2 = 0 ;
8379 double result;
8380 void *argp1 = 0 ;
8381 int res1 = 0 ;
8382 wxPoint2D temp2 ;
8383 PyObject * obj0 = 0 ;
8384 PyObject * obj1 = 0 ;
8385 char * kwnames[] = {
8386 (char *) "self",(char *) "vec", NULL
8387 };
8388
8389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8391 if (!SWIG_IsOK(res1)) {
8392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8393 }
8394 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8395 {
8396 arg2 = &temp2;
8397 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8398 }
8399 {
8400 PyThreadState* __tstate = wxPyBeginAllowThreads();
8401 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8402 wxPyEndAllowThreads(__tstate);
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_From_double(static_cast< double >(result));
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8413 PyObject *resultobj = 0;
8414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8415 wxPoint2D result;
8416 void *argp1 = 0 ;
8417 int res1 = 0 ;
8418 PyObject *swig_obj[1] ;
8419
8420 if (!args) SWIG_fail;
8421 swig_obj[0] = args;
8422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8423 if (!SWIG_IsOK(res1)) {
8424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8425 }
8426 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8427 {
8428 PyThreadState* __tstate = wxPyBeginAllowThreads();
8429 result = (arg1)->operator -();
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8441 PyObject *resultobj = 0;
8442 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8443 wxPoint2D *arg2 = 0 ;
8444 wxPoint2D *result = 0 ;
8445 void *argp1 = 0 ;
8446 int res1 = 0 ;
8447 wxPoint2D temp2 ;
8448 PyObject * obj0 = 0 ;
8449 PyObject * obj1 = 0 ;
8450 char * kwnames[] = {
8451 (char *) "self",(char *) "pt", NULL
8452 };
8453
8454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8456 if (!SWIG_IsOK(res1)) {
8457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8458 }
8459 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8460 {
8461 arg2 = &temp2;
8462 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8463 }
8464 {
8465 PyThreadState* __tstate = wxPyBeginAllowThreads();
8466 {
8467 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8468 result = (wxPoint2D *) &_result_ref;
8469 }
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8481 PyObject *resultobj = 0;
8482 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8483 wxPoint2D *arg2 = 0 ;
8484 wxPoint2D *result = 0 ;
8485 void *argp1 = 0 ;
8486 int res1 = 0 ;
8487 wxPoint2D temp2 ;
8488 PyObject * obj0 = 0 ;
8489 PyObject * obj1 = 0 ;
8490 char * kwnames[] = {
8491 (char *) "self",(char *) "pt", NULL
8492 };
8493
8494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8496 if (!SWIG_IsOK(res1)) {
8497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8498 }
8499 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8500 {
8501 arg2 = &temp2;
8502 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8503 }
8504 {
8505 PyThreadState* __tstate = wxPyBeginAllowThreads();
8506 {
8507 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8508 result = (wxPoint2D *) &_result_ref;
8509 }
8510 wxPyEndAllowThreads(__tstate);
8511 if (PyErr_Occurred()) SWIG_fail;
8512 }
8513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8514 return resultobj;
8515 fail:
8516 return NULL;
8517 }
8518
8519
8520 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8521 PyObject *resultobj = 0;
8522 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8523 wxPoint2D *arg2 = 0 ;
8524 wxPoint2D *result = 0 ;
8525 void *argp1 = 0 ;
8526 int res1 = 0 ;
8527 wxPoint2D temp2 ;
8528 PyObject * obj0 = 0 ;
8529 PyObject * obj1 = 0 ;
8530 char * kwnames[] = {
8531 (char *) "self",(char *) "pt", NULL
8532 };
8533
8534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8538 }
8539 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8540 {
8541 arg2 = &temp2;
8542 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8543 }
8544 {
8545 PyThreadState* __tstate = wxPyBeginAllowThreads();
8546 {
8547 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8548 result = (wxPoint2D *) &_result_ref;
8549 }
8550 wxPyEndAllowThreads(__tstate);
8551 if (PyErr_Occurred()) SWIG_fail;
8552 }
8553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8554 return resultobj;
8555 fail:
8556 return NULL;
8557 }
8558
8559
8560 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8561 PyObject *resultobj = 0;
8562 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8563 wxPoint2D *arg2 = 0 ;
8564 wxPoint2D *result = 0 ;
8565 void *argp1 = 0 ;
8566 int res1 = 0 ;
8567 wxPoint2D temp2 ;
8568 PyObject * obj0 = 0 ;
8569 PyObject * obj1 = 0 ;
8570 char * kwnames[] = {
8571 (char *) "self",(char *) "pt", NULL
8572 };
8573
8574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8576 if (!SWIG_IsOK(res1)) {
8577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8578 }
8579 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8580 {
8581 arg2 = &temp2;
8582 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8583 }
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 {
8587 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8588 result = (wxPoint2D *) &_result_ref;
8589 }
8590 wxPyEndAllowThreads(__tstate);
8591 if (PyErr_Occurred()) SWIG_fail;
8592 }
8593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8594 return resultobj;
8595 fail:
8596 return NULL;
8597 }
8598
8599
8600 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8601 PyObject *resultobj = 0;
8602 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8603 PyObject *arg2 = (PyObject *) 0 ;
8604 bool result;
8605 void *argp1 = 0 ;
8606 int res1 = 0 ;
8607 PyObject * obj0 = 0 ;
8608 PyObject * obj1 = 0 ;
8609 char * kwnames[] = {
8610 (char *) "self",(char *) "other", NULL
8611 };
8612
8613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8617 }
8618 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8619 arg2 = obj1;
8620 {
8621 result = (bool)wxPoint2D___eq__(arg1,arg2);
8622 if (PyErr_Occurred()) SWIG_fail;
8623 }
8624 {
8625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8626 }
8627 return resultobj;
8628 fail:
8629 return NULL;
8630 }
8631
8632
8633 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8634 PyObject *resultobj = 0;
8635 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8636 PyObject *arg2 = (PyObject *) 0 ;
8637 bool result;
8638 void *argp1 = 0 ;
8639 int res1 = 0 ;
8640 PyObject * obj0 = 0 ;
8641 PyObject * obj1 = 0 ;
8642 char * kwnames[] = {
8643 (char *) "self",(char *) "other", NULL
8644 };
8645
8646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8648 if (!SWIG_IsOK(res1)) {
8649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8650 }
8651 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8652 arg2 = obj1;
8653 {
8654 result = (bool)wxPoint2D___ne__(arg1,arg2);
8655 if (PyErr_Occurred()) SWIG_fail;
8656 }
8657 {
8658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8659 }
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8667 PyObject *resultobj = 0;
8668 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8669 double arg2 ;
8670 void *argp1 = 0 ;
8671 int res1 = 0 ;
8672 double val2 ;
8673 int ecode2 = 0 ;
8674 PyObject *swig_obj[2] ;
8675
8676 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8678 if (!SWIG_IsOK(res1)) {
8679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8680 }
8681 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8682 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8683 if (!SWIG_IsOK(ecode2)) {
8684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8685 }
8686 arg2 = static_cast< double >(val2);
8687 if (arg1) (arg1)->m_x = arg2;
8688
8689 resultobj = SWIG_Py_Void();
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 double result;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 PyObject *swig_obj[1] ;
8703
8704 if (!args) SWIG_fail;
8705 swig_obj[0] = args;
8706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8707 if (!SWIG_IsOK(res1)) {
8708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8709 }
8710 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8711 result = (double) ((arg1)->m_x);
8712 resultobj = SWIG_From_double(static_cast< double >(result));
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 double arg2 ;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 double val2 ;
8726 int ecode2 = 0 ;
8727 PyObject *swig_obj[2] ;
8728
8729 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8731 if (!SWIG_IsOK(res1)) {
8732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8733 }
8734 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8735 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8736 if (!SWIG_IsOK(ecode2)) {
8737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8738 }
8739 arg2 = static_cast< double >(val2);
8740 if (arg1) (arg1)->m_y = arg2;
8741
8742 resultobj = SWIG_Py_Void();
8743 return resultobj;
8744 fail:
8745 return NULL;
8746 }
8747
8748
8749 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8750 PyObject *resultobj = 0;
8751 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8752 double result;
8753 void *argp1 = 0 ;
8754 int res1 = 0 ;
8755 PyObject *swig_obj[1] ;
8756
8757 if (!args) SWIG_fail;
8758 swig_obj[0] = args;
8759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8760 if (!SWIG_IsOK(res1)) {
8761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8762 }
8763 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8764 result = (double) ((arg1)->m_y);
8765 resultobj = SWIG_From_double(static_cast< double >(result));
8766 return resultobj;
8767 fail:
8768 return NULL;
8769 }
8770
8771
8772 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj = 0;
8774 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8775 double arg2 = (double) 0 ;
8776 double arg3 = (double) 0 ;
8777 void *argp1 = 0 ;
8778 int res1 = 0 ;
8779 double val2 ;
8780 int ecode2 = 0 ;
8781 double val3 ;
8782 int ecode3 = 0 ;
8783 PyObject * obj0 = 0 ;
8784 PyObject * obj1 = 0 ;
8785 PyObject * obj2 = 0 ;
8786 char * kwnames[] = {
8787 (char *) "self",(char *) "x",(char *) "y", NULL
8788 };
8789
8790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8792 if (!SWIG_IsOK(res1)) {
8793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8794 }
8795 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8796 if (obj1) {
8797 ecode2 = SWIG_AsVal_double(obj1, &val2);
8798 if (!SWIG_IsOK(ecode2)) {
8799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8800 }
8801 arg2 = static_cast< double >(val2);
8802 }
8803 if (obj2) {
8804 ecode3 = SWIG_AsVal_double(obj2, &val3);
8805 if (!SWIG_IsOK(ecode3)) {
8806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8807 }
8808 arg3 = static_cast< double >(val3);
8809 }
8810 {
8811 PyThreadState* __tstate = wxPyBeginAllowThreads();
8812 wxPoint2D_Set(arg1,arg2,arg3);
8813 wxPyEndAllowThreads(__tstate);
8814 if (PyErr_Occurred()) SWIG_fail;
8815 }
8816 resultobj = SWIG_Py_Void();
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8824 PyObject *resultobj = 0;
8825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8826 PyObject *result = 0 ;
8827 void *argp1 = 0 ;
8828 int res1 = 0 ;
8829 PyObject *swig_obj[1] ;
8830
8831 if (!args) SWIG_fail;
8832 swig_obj[0] = args;
8833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8834 if (!SWIG_IsOK(res1)) {
8835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8836 }
8837 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (PyObject *)wxPoint2D_Get(arg1);
8841 wxPyEndAllowThreads(__tstate);
8842 if (PyErr_Occurred()) SWIG_fail;
8843 }
8844 resultobj = result;
8845 return resultobj;
8846 fail:
8847 return NULL;
8848 }
8849
8850
8851 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8852 PyObject *obj;
8853 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8854 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8855 return SWIG_Py_Void();
8856 }
8857
8858 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8859 return SWIG_Python_InitShadowInstance(args);
8860 }
8861
8862 SWIGINTERN int DefaultPosition_set(PyObject *) {
8863 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8864 return 1;
8865 }
8866
8867
8868 SWIGINTERN PyObject *DefaultPosition_get(void) {
8869 PyObject *pyobj = 0;
8870
8871 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8872 return pyobj;
8873 }
8874
8875
8876 SWIGINTERN int DefaultSize_set(PyObject *) {
8877 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8878 return 1;
8879 }
8880
8881
8882 SWIGINTERN PyObject *DefaultSize_get(void) {
8883 PyObject *pyobj = 0;
8884
8885 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8886 return pyobj;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 PyObject *arg1 = (PyObject *) 0 ;
8893 wxPyInputStream *result = 0 ;
8894 PyObject * obj0 = 0 ;
8895 char * kwnames[] = {
8896 (char *) "p", NULL
8897 };
8898
8899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8900 arg1 = obj0;
8901 {
8902 PyThreadState* __tstate = wxPyBeginAllowThreads();
8903 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8908 return resultobj;
8909 fail:
8910 return NULL;
8911 }
8912
8913
8914 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8915 PyObject *resultobj = 0;
8916 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8917 void *argp1 = 0 ;
8918 int res1 = 0 ;
8919 PyObject *swig_obj[1] ;
8920
8921 if (!args) SWIG_fail;
8922 swig_obj[0] = args;
8923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8924 if (!SWIG_IsOK(res1)) {
8925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8926 }
8927 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 delete arg1;
8931
8932 wxPyEndAllowThreads(__tstate);
8933 if (PyErr_Occurred()) SWIG_fail;
8934 }
8935 resultobj = SWIG_Py_Void();
8936 return resultobj;
8937 fail:
8938 return NULL;
8939 }
8940
8941
8942 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8943 PyObject *resultobj = 0;
8944 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject *swig_obj[1] ;
8948
8949 if (!args) SWIG_fail;
8950 swig_obj[0] = args;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 (arg1)->close();
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_flush(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_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8981 }
8982 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8983 {
8984 PyThreadState* __tstate = wxPyBeginAllowThreads();
8985 (arg1)->flush();
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_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8997 PyObject *resultobj = 0;
8998 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8999 bool result;
9000 void *argp1 = 0 ;
9001 int res1 = 0 ;
9002 PyObject *swig_obj[1] ;
9003
9004 if (!args) SWIG_fail;
9005 swig_obj[0] = args;
9006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9007 if (!SWIG_IsOK(res1)) {
9008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9009 }
9010 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9011 {
9012 PyThreadState* __tstate = wxPyBeginAllowThreads();
9013 result = (bool)(arg1)->eof();
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 {
9018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9019 }
9020 return resultobj;
9021 fail:
9022 return NULL;
9023 }
9024
9025
9026 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9027 PyObject *resultobj = 0;
9028 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9029 int arg2 = (int) -1 ;
9030 PyObject *result = 0 ;
9031 void *argp1 = 0 ;
9032 int res1 = 0 ;
9033 int val2 ;
9034 int ecode2 = 0 ;
9035 PyObject * obj0 = 0 ;
9036 PyObject * obj1 = 0 ;
9037 char * kwnames[] = {
9038 (char *) "self",(char *) "size", NULL
9039 };
9040
9041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9043 if (!SWIG_IsOK(res1)) {
9044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9045 }
9046 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9047 if (obj1) {
9048 ecode2 = SWIG_AsVal_int(obj1, &val2);
9049 if (!SWIG_IsOK(ecode2)) {
9050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9051 }
9052 arg2 = static_cast< int >(val2);
9053 }
9054 {
9055 PyThreadState* __tstate = wxPyBeginAllowThreads();
9056 result = (PyObject *)(arg1)->read(arg2);
9057 wxPyEndAllowThreads(__tstate);
9058 if (PyErr_Occurred()) SWIG_fail;
9059 }
9060 resultobj = result;
9061 return resultobj;
9062 fail:
9063 return NULL;
9064 }
9065
9066
9067 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9068 PyObject *resultobj = 0;
9069 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9070 int arg2 = (int) -1 ;
9071 PyObject *result = 0 ;
9072 void *argp1 = 0 ;
9073 int res1 = 0 ;
9074 int val2 ;
9075 int ecode2 = 0 ;
9076 PyObject * obj0 = 0 ;
9077 PyObject * obj1 = 0 ;
9078 char * kwnames[] = {
9079 (char *) "self",(char *) "size", NULL
9080 };
9081
9082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9084 if (!SWIG_IsOK(res1)) {
9085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9086 }
9087 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9088 if (obj1) {
9089 ecode2 = SWIG_AsVal_int(obj1, &val2);
9090 if (!SWIG_IsOK(ecode2)) {
9091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9092 }
9093 arg2 = static_cast< int >(val2);
9094 }
9095 {
9096 PyThreadState* __tstate = wxPyBeginAllowThreads();
9097 result = (PyObject *)(arg1)->readline(arg2);
9098 wxPyEndAllowThreads(__tstate);
9099 if (PyErr_Occurred()) SWIG_fail;
9100 }
9101 resultobj = result;
9102 return resultobj;
9103 fail:
9104 return NULL;
9105 }
9106
9107
9108 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9109 PyObject *resultobj = 0;
9110 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9111 int arg2 = (int) -1 ;
9112 PyObject *result = 0 ;
9113 void *argp1 = 0 ;
9114 int res1 = 0 ;
9115 int val2 ;
9116 int ecode2 = 0 ;
9117 PyObject * obj0 = 0 ;
9118 PyObject * obj1 = 0 ;
9119 char * kwnames[] = {
9120 (char *) "self",(char *) "sizehint", NULL
9121 };
9122
9123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9127 }
9128 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9129 if (obj1) {
9130 ecode2 = SWIG_AsVal_int(obj1, &val2);
9131 if (!SWIG_IsOK(ecode2)) {
9132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9133 }
9134 arg2 = static_cast< int >(val2);
9135 }
9136 {
9137 PyThreadState* __tstate = wxPyBeginAllowThreads();
9138 result = (PyObject *)(arg1)->readlines(arg2);
9139 wxPyEndAllowThreads(__tstate);
9140 if (PyErr_Occurred()) SWIG_fail;
9141 }
9142 resultobj = result;
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj = 0;
9151 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9152 int arg2 ;
9153 int arg3 = (int) 0 ;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 int val2 ;
9157 int ecode2 = 0 ;
9158 int val3 ;
9159 int ecode3 = 0 ;
9160 PyObject * obj0 = 0 ;
9161 PyObject * obj1 = 0 ;
9162 PyObject * obj2 = 0 ;
9163 char * kwnames[] = {
9164 (char *) "self",(char *) "offset",(char *) "whence", NULL
9165 };
9166
9167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9169 if (!SWIG_IsOK(res1)) {
9170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9171 }
9172 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9173 ecode2 = SWIG_AsVal_int(obj1, &val2);
9174 if (!SWIG_IsOK(ecode2)) {
9175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9176 }
9177 arg2 = static_cast< int >(val2);
9178 if (obj2) {
9179 ecode3 = SWIG_AsVal_int(obj2, &val3);
9180 if (!SWIG_IsOK(ecode3)) {
9181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9182 }
9183 arg3 = static_cast< int >(val3);
9184 }
9185 {
9186 PyThreadState* __tstate = wxPyBeginAllowThreads();
9187 (arg1)->seek(arg2,arg3);
9188 wxPyEndAllowThreads(__tstate);
9189 if (PyErr_Occurred()) SWIG_fail;
9190 }
9191 resultobj = SWIG_Py_Void();
9192 return resultobj;
9193 fail:
9194 return NULL;
9195 }
9196
9197
9198 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 PyObject *resultobj = 0;
9200 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9201 int result;
9202 void *argp1 = 0 ;
9203 int res1 = 0 ;
9204 PyObject *swig_obj[1] ;
9205
9206 if (!args) SWIG_fail;
9207 swig_obj[0] = args;
9208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9209 if (!SWIG_IsOK(res1)) {
9210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9211 }
9212 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (int)(arg1)->tell();
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = SWIG_From_int(static_cast< int >(result));
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9227 PyObject *resultobj = 0;
9228 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9229 char result;
9230 void *argp1 = 0 ;
9231 int res1 = 0 ;
9232 PyObject *swig_obj[1] ;
9233
9234 if (!args) SWIG_fail;
9235 swig_obj[0] = args;
9236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9237 if (!SWIG_IsOK(res1)) {
9238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9239 }
9240 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9241 {
9242 PyThreadState* __tstate = wxPyBeginAllowThreads();
9243 result = (char)(arg1)->Peek();
9244 wxPyEndAllowThreads(__tstate);
9245 if (PyErr_Occurred()) SWIG_fail;
9246 }
9247 resultobj = SWIG_From_char(static_cast< char >(result));
9248 return resultobj;
9249 fail:
9250 return NULL;
9251 }
9252
9253
9254 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9255 PyObject *resultobj = 0;
9256 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9257 char result;
9258 void *argp1 = 0 ;
9259 int res1 = 0 ;
9260 PyObject *swig_obj[1] ;
9261
9262 if (!args) SWIG_fail;
9263 swig_obj[0] = args;
9264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9265 if (!SWIG_IsOK(res1)) {
9266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9267 }
9268 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (char)(arg1)->GetC();
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_From_char(static_cast< char >(result));
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 size_t result;
9286 void *argp1 = 0 ;
9287 int res1 = 0 ;
9288 PyObject *swig_obj[1] ;
9289
9290 if (!args) SWIG_fail;
9291 swig_obj[0] = args;
9292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9293 if (!SWIG_IsOK(res1)) {
9294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9295 }
9296 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9297 {
9298 PyThreadState* __tstate = wxPyBeginAllowThreads();
9299 result = (size_t)(arg1)->LastRead();
9300 wxPyEndAllowThreads(__tstate);
9301 if (PyErr_Occurred()) SWIG_fail;
9302 }
9303 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9304 return resultobj;
9305 fail:
9306 return NULL;
9307 }
9308
9309
9310 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9311 PyObject *resultobj = 0;
9312 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9313 bool result;
9314 void *argp1 = 0 ;
9315 int res1 = 0 ;
9316 PyObject *swig_obj[1] ;
9317
9318 if (!args) SWIG_fail;
9319 swig_obj[0] = args;
9320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9321 if (!SWIG_IsOK(res1)) {
9322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9323 }
9324 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (bool)(arg1)->CanRead();
9328 wxPyEndAllowThreads(__tstate);
9329 if (PyErr_Occurred()) SWIG_fail;
9330 }
9331 {
9332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9333 }
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9341 PyObject *resultobj = 0;
9342 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9343 bool result;
9344 void *argp1 = 0 ;
9345 int res1 = 0 ;
9346 PyObject *swig_obj[1] ;
9347
9348 if (!args) SWIG_fail;
9349 swig_obj[0] = args;
9350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9351 if (!SWIG_IsOK(res1)) {
9352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9353 }
9354 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9355 {
9356 PyThreadState* __tstate = wxPyBeginAllowThreads();
9357 result = (bool)(arg1)->Eof();
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 {
9362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9363 }
9364 return resultobj;
9365 fail:
9366 return NULL;
9367 }
9368
9369
9370 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9371 PyObject *resultobj = 0;
9372 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9373 char arg2 ;
9374 bool result;
9375 void *argp1 = 0 ;
9376 int res1 = 0 ;
9377 char val2 ;
9378 int ecode2 = 0 ;
9379 PyObject * obj0 = 0 ;
9380 PyObject * obj1 = 0 ;
9381 char * kwnames[] = {
9382 (char *) "self",(char *) "c", NULL
9383 };
9384
9385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9387 if (!SWIG_IsOK(res1)) {
9388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9389 }
9390 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9391 ecode2 = SWIG_AsVal_char(obj1, &val2);
9392 if (!SWIG_IsOK(ecode2)) {
9393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9394 }
9395 arg2 = static_cast< char >(val2);
9396 {
9397 PyThreadState* __tstate = wxPyBeginAllowThreads();
9398 result = (bool)(arg1)->Ungetch(arg2);
9399 wxPyEndAllowThreads(__tstate);
9400 if (PyErr_Occurred()) SWIG_fail;
9401 }
9402 {
9403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9404 }
9405 return resultobj;
9406 fail:
9407 return NULL;
9408 }
9409
9410
9411 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9412 PyObject *resultobj = 0;
9413 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9414 long arg2 ;
9415 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9416 long result;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 long val2 ;
9420 int ecode2 = 0 ;
9421 int val3 ;
9422 int ecode3 = 0 ;
9423 PyObject * obj0 = 0 ;
9424 PyObject * obj1 = 0 ;
9425 PyObject * obj2 = 0 ;
9426 char * kwnames[] = {
9427 (char *) "self",(char *) "pos",(char *) "mode", NULL
9428 };
9429
9430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9432 if (!SWIG_IsOK(res1)) {
9433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9434 }
9435 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9436 ecode2 = SWIG_AsVal_long(obj1, &val2);
9437 if (!SWIG_IsOK(ecode2)) {
9438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9439 }
9440 arg2 = static_cast< long >(val2);
9441 if (obj2) {
9442 ecode3 = SWIG_AsVal_int(obj2, &val3);
9443 if (!SWIG_IsOK(ecode3)) {
9444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9445 }
9446 arg3 = static_cast< wxSeekMode >(val3);
9447 }
9448 {
9449 PyThreadState* __tstate = wxPyBeginAllowThreads();
9450 result = (long)(arg1)->SeekI(arg2,arg3);
9451 wxPyEndAllowThreads(__tstate);
9452 if (PyErr_Occurred()) SWIG_fail;
9453 }
9454 resultobj = SWIG_From_long(static_cast< long >(result));
9455 return resultobj;
9456 fail:
9457 return NULL;
9458 }
9459
9460
9461 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9462 PyObject *resultobj = 0;
9463 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9464 long result;
9465 void *argp1 = 0 ;
9466 int res1 = 0 ;
9467 PyObject *swig_obj[1] ;
9468
9469 if (!args) SWIG_fail;
9470 swig_obj[0] = args;
9471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9472 if (!SWIG_IsOK(res1)) {
9473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9474 }
9475 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9476 {
9477 PyThreadState* __tstate = wxPyBeginAllowThreads();
9478 result = (long)(arg1)->TellI();
9479 wxPyEndAllowThreads(__tstate);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_From_long(static_cast< long >(result));
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *obj;
9491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9492 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9493 return SWIG_Py_Void();
9494 }
9495
9496 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9497 return SWIG_Python_InitShadowInstance(args);
9498 }
9499
9500 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj = 0;
9502 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9503 PyObject *arg2 = (PyObject *) 0 ;
9504 void *argp1 = 0 ;
9505 int res1 = 0 ;
9506 PyObject * obj0 = 0 ;
9507 PyObject * obj1 = 0 ;
9508 char * kwnames[] = {
9509 (char *) "self",(char *) "obj", NULL
9510 };
9511
9512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9514 if (!SWIG_IsOK(res1)) {
9515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9516 }
9517 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9518 arg2 = obj1;
9519 {
9520 PyThreadState* __tstate = wxPyBeginAllowThreads();
9521 wxOutputStream_write(arg1,arg2);
9522 wxPyEndAllowThreads(__tstate);
9523 if (PyErr_Occurred()) SWIG_fail;
9524 }
9525 resultobj = SWIG_Py_Void();
9526 return resultobj;
9527 fail:
9528 return NULL;
9529 }
9530
9531
9532 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9533 PyObject *resultobj = 0;
9534 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9535 size_t result;
9536 void *argp1 = 0 ;
9537 int res1 = 0 ;
9538 PyObject *swig_obj[1] ;
9539
9540 if (!args) SWIG_fail;
9541 swig_obj[0] = args;
9542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9543 if (!SWIG_IsOK(res1)) {
9544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9545 }
9546 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9547 {
9548 PyThreadState* __tstate = wxPyBeginAllowThreads();
9549 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9550 wxPyEndAllowThreads(__tstate);
9551 if (PyErr_Occurred()) SWIG_fail;
9552 }
9553 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9554 return resultobj;
9555 fail:
9556 return NULL;
9557 }
9558
9559
9560 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9561 PyObject *obj;
9562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9563 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9564 return SWIG_Py_Void();
9565 }
9566
9567 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9568 PyObject *resultobj = 0;
9569 wxInputStream *arg1 = (wxInputStream *) 0 ;
9570 wxString *arg2 = 0 ;
9571 wxString *arg3 = 0 ;
9572 wxString *arg4 = 0 ;
9573 wxDateTime arg5 ;
9574 wxFSFile *result = 0 ;
9575 wxPyInputStream *temp1 ;
9576 bool temp2 = false ;
9577 bool temp3 = false ;
9578 bool temp4 = false ;
9579 void *argp5 ;
9580 int res5 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 PyObject * obj2 = 0 ;
9584 PyObject * obj3 = 0 ;
9585 PyObject * obj4 = 0 ;
9586 char * kwnames[] = {
9587 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9588 };
9589
9590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9591 {
9592 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9593 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9594 } else {
9595 PyErr_Clear(); // clear the failure of the wxPyConvert above
9596 arg1 = wxPyCBInputStream_create(obj0, true);
9597 if (arg1 == NULL) {
9598 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9599 SWIG_fail;
9600 }
9601 }
9602 }
9603 {
9604 arg2 = wxString_in_helper(obj1);
9605 if (arg2 == NULL) SWIG_fail;
9606 temp2 = true;
9607 }
9608 {
9609 arg3 = wxString_in_helper(obj2);
9610 if (arg3 == NULL) SWIG_fail;
9611 temp3 = true;
9612 }
9613 {
9614 arg4 = wxString_in_helper(obj3);
9615 if (arg4 == NULL) SWIG_fail;
9616 temp4 = true;
9617 }
9618 {
9619 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9620 if (!SWIG_IsOK(res5)) {
9621 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9622 }
9623 if (!argp5) {
9624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9625 } else {
9626 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9627 arg5 = *temp;
9628 if (SWIG_IsNewObj(res5)) delete temp;
9629 }
9630 }
9631 {
9632 PyThreadState* __tstate = wxPyBeginAllowThreads();
9633 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9634 wxPyEndAllowThreads(__tstate);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 {
9638 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9639 }
9640 {
9641 if (temp2)
9642 delete arg2;
9643 }
9644 {
9645 if (temp3)
9646 delete arg3;
9647 }
9648 {
9649 if (temp4)
9650 delete arg4;
9651 }
9652 return resultobj;
9653 fail:
9654 {
9655 if (temp2)
9656 delete arg2;
9657 }
9658 {
9659 if (temp3)
9660 delete arg3;
9661 }
9662 {
9663 if (temp4)
9664 delete arg4;
9665 }
9666 return NULL;
9667 }
9668
9669
9670 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9671 PyObject *resultobj = 0;
9672 wxFSFile *arg1 = (wxFSFile *) 0 ;
9673 void *argp1 = 0 ;
9674 int res1 = 0 ;
9675 PyObject *swig_obj[1] ;
9676
9677 if (!args) SWIG_fail;
9678 swig_obj[0] = args;
9679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9680 if (!SWIG_IsOK(res1)) {
9681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9682 }
9683 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9684 {
9685 PyThreadState* __tstate = wxPyBeginAllowThreads();
9686 delete arg1;
9687
9688 wxPyEndAllowThreads(__tstate);
9689 if (PyErr_Occurred()) SWIG_fail;
9690 }
9691 resultobj = SWIG_Py_Void();
9692 return resultobj;
9693 fail:
9694 return NULL;
9695 }
9696
9697
9698 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9699 PyObject *resultobj = 0;
9700 wxFSFile *arg1 = (wxFSFile *) 0 ;
9701 wxInputStream *result = 0 ;
9702 void *argp1 = 0 ;
9703 int res1 = 0 ;
9704 PyObject *swig_obj[1] ;
9705
9706 if (!args) SWIG_fail;
9707 swig_obj[0] = args;
9708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9709 if (!SWIG_IsOK(res1)) {
9710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9711 }
9712 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9713 {
9714 PyThreadState* __tstate = wxPyBeginAllowThreads();
9715 result = (wxInputStream *)(arg1)->GetStream();
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 {
9720 wxPyInputStream * _ptr = NULL;
9721
9722 if (result) {
9723 _ptr = new wxPyInputStream(result);
9724 }
9725 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9726 }
9727 return resultobj;
9728 fail:
9729 return NULL;
9730 }
9731
9732
9733 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9734 PyObject *resultobj = 0;
9735 wxFSFile *arg1 = (wxFSFile *) 0 ;
9736 wxString *result = 0 ;
9737 void *argp1 = 0 ;
9738 int res1 = 0 ;
9739 PyObject *swig_obj[1] ;
9740
9741 if (!args) SWIG_fail;
9742 swig_obj[0] = args;
9743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9744 if (!SWIG_IsOK(res1)) {
9745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9746 }
9747 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9748 {
9749 PyThreadState* __tstate = wxPyBeginAllowThreads();
9750 {
9751 wxString const &_result_ref = (arg1)->GetMimeType();
9752 result = (wxString *) &_result_ref;
9753 }
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 {
9758 #if wxUSE_UNICODE
9759 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9760 #else
9761 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9762 #endif
9763 }
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9771 PyObject *resultobj = 0;
9772 wxFSFile *arg1 = (wxFSFile *) 0 ;
9773 wxString *result = 0 ;
9774 void *argp1 = 0 ;
9775 int res1 = 0 ;
9776 PyObject *swig_obj[1] ;
9777
9778 if (!args) SWIG_fail;
9779 swig_obj[0] = args;
9780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9781 if (!SWIG_IsOK(res1)) {
9782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9783 }
9784 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9785 {
9786 PyThreadState* __tstate = wxPyBeginAllowThreads();
9787 {
9788 wxString const &_result_ref = (arg1)->GetLocation();
9789 result = (wxString *) &_result_ref;
9790 }
9791 wxPyEndAllowThreads(__tstate);
9792 if (PyErr_Occurred()) SWIG_fail;
9793 }
9794 {
9795 #if wxUSE_UNICODE
9796 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9797 #else
9798 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9799 #endif
9800 }
9801 return resultobj;
9802 fail:
9803 return NULL;
9804 }
9805
9806
9807 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9808 PyObject *resultobj = 0;
9809 wxFSFile *arg1 = (wxFSFile *) 0 ;
9810 wxString *result = 0 ;
9811 void *argp1 = 0 ;
9812 int res1 = 0 ;
9813 PyObject *swig_obj[1] ;
9814
9815 if (!args) SWIG_fail;
9816 swig_obj[0] = args;
9817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9820 }
9821 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 {
9825 wxString const &_result_ref = (arg1)->GetAnchor();
9826 result = (wxString *) &_result_ref;
9827 }
9828 wxPyEndAllowThreads(__tstate);
9829 if (PyErr_Occurred()) SWIG_fail;
9830 }
9831 {
9832 #if wxUSE_UNICODE
9833 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9834 #else
9835 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9836 #endif
9837 }
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *resultobj = 0;
9846 wxFSFile *arg1 = (wxFSFile *) 0 ;
9847 wxDateTime result;
9848 void *argp1 = 0 ;
9849 int res1 = 0 ;
9850 PyObject *swig_obj[1] ;
9851
9852 if (!args) SWIG_fail;
9853 swig_obj[0] = args;
9854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9855 if (!SWIG_IsOK(res1)) {
9856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9857 }
9858 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9859 {
9860 PyThreadState* __tstate = wxPyBeginAllowThreads();
9861 result = (arg1)->GetModificationTime();
9862 wxPyEndAllowThreads(__tstate);
9863 if (PyErr_Occurred()) SWIG_fail;
9864 }
9865 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9866 return resultobj;
9867 fail:
9868 return NULL;
9869 }
9870
9871
9872 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9873 PyObject *obj;
9874 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9875 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9876 return SWIG_Py_Void();
9877 }
9878
9879 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9880 return SWIG_Python_InitShadowInstance(args);
9881 }
9882
9883 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9884 PyObject *resultobj = 0;
9885 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9886 void *argp1 = 0 ;
9887 int res1 = 0 ;
9888 PyObject *swig_obj[1] ;
9889
9890 if (!args) SWIG_fail;
9891 swig_obj[0] = args;
9892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9893 if (!SWIG_IsOK(res1)) {
9894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9895 }
9896 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9897 {
9898 PyThreadState* __tstate = wxPyBeginAllowThreads();
9899 delete arg1;
9900
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 resultobj = SWIG_Py_Void();
9905 return resultobj;
9906 fail:
9907 return NULL;
9908 }
9909
9910
9911 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9912 PyObject *obj;
9913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9914 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9915 return SWIG_Py_Void();
9916 }
9917
9918 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxPyFileSystemHandler *result = 0 ;
9921
9922 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj = 0;
9938 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9939 PyObject *arg2 = (PyObject *) 0 ;
9940 PyObject *arg3 = (PyObject *) 0 ;
9941 void *argp1 = 0 ;
9942 int res1 = 0 ;
9943 PyObject * obj0 = 0 ;
9944 PyObject * obj1 = 0 ;
9945 PyObject * obj2 = 0 ;
9946 char * kwnames[] = {
9947 (char *) "self",(char *) "self",(char *) "_class", NULL
9948 };
9949
9950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9952 if (!SWIG_IsOK(res1)) {
9953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9954 }
9955 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9956 arg2 = obj1;
9957 arg3 = obj2;
9958 {
9959 PyThreadState* __tstate = wxPyBeginAllowThreads();
9960 (arg1)->_setCallbackInfo(arg2,arg3);
9961 wxPyEndAllowThreads(__tstate);
9962 if (PyErr_Occurred()) SWIG_fail;
9963 }
9964 resultobj = SWIG_Py_Void();
9965 return resultobj;
9966 fail:
9967 return NULL;
9968 }
9969
9970
9971 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9972 PyObject *resultobj = 0;
9973 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9974 wxString *arg2 = 0 ;
9975 bool result;
9976 void *argp1 = 0 ;
9977 int res1 = 0 ;
9978 bool temp2 = false ;
9979 PyObject * obj0 = 0 ;
9980 PyObject * obj1 = 0 ;
9981 char * kwnames[] = {
9982 (char *) "self",(char *) "location", NULL
9983 };
9984
9985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9989 }
9990 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9991 {
9992 arg2 = wxString_in_helper(obj1);
9993 if (arg2 == NULL) SWIG_fail;
9994 temp2 = true;
9995 }
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 {
10003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10004 }
10005 {
10006 if (temp2)
10007 delete arg2;
10008 }
10009 return resultobj;
10010 fail:
10011 {
10012 if (temp2)
10013 delete arg2;
10014 }
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10020 PyObject *resultobj = 0;
10021 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10022 wxFileSystem *arg2 = 0 ;
10023 wxString *arg3 = 0 ;
10024 wxFSFile *result = 0 ;
10025 void *argp1 = 0 ;
10026 int res1 = 0 ;
10027 void *argp2 = 0 ;
10028 int res2 = 0 ;
10029 bool temp3 = false ;
10030 PyObject * obj0 = 0 ;
10031 PyObject * obj1 = 0 ;
10032 PyObject * obj2 = 0 ;
10033 char * kwnames[] = {
10034 (char *) "self",(char *) "fs",(char *) "location", NULL
10035 };
10036
10037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10039 if (!SWIG_IsOK(res1)) {
10040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10041 }
10042 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10043 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10044 if (!SWIG_IsOK(res2)) {
10045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10046 }
10047 if (!argp2) {
10048 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10049 }
10050 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10051 {
10052 arg3 = wxString_in_helper(obj2);
10053 if (arg3 == NULL) SWIG_fail;
10054 temp3 = true;
10055 }
10056 {
10057 PyThreadState* __tstate = wxPyBeginAllowThreads();
10058 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 {
10063 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10064 }
10065 {
10066 if (temp3)
10067 delete arg3;
10068 }
10069 return resultobj;
10070 fail:
10071 {
10072 if (temp3)
10073 delete arg3;
10074 }
10075 return NULL;
10076 }
10077
10078
10079 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj = 0;
10081 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10082 wxString *arg2 = 0 ;
10083 int arg3 = (int) 0 ;
10084 wxString result;
10085 void *argp1 = 0 ;
10086 int res1 = 0 ;
10087 bool temp2 = false ;
10088 int val3 ;
10089 int ecode3 = 0 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 PyObject * obj2 = 0 ;
10093 char * kwnames[] = {
10094 (char *) "self",(char *) "spec",(char *) "flags", NULL
10095 };
10096
10097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10099 if (!SWIG_IsOK(res1)) {
10100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10101 }
10102 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10103 {
10104 arg2 = wxString_in_helper(obj1);
10105 if (arg2 == NULL) SWIG_fail;
10106 temp2 = true;
10107 }
10108 if (obj2) {
10109 ecode3 = SWIG_AsVal_int(obj2, &val3);
10110 if (!SWIG_IsOK(ecode3)) {
10111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10112 }
10113 arg3 = static_cast< int >(val3);
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 {
10122 #if wxUSE_UNICODE
10123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10124 #else
10125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10126 #endif
10127 }
10128 {
10129 if (temp2)
10130 delete arg2;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp2)
10136 delete arg2;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10143 PyObject *resultobj = 0;
10144 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10145 wxString result;
10146 void *argp1 = 0 ;
10147 int res1 = 0 ;
10148 PyObject *swig_obj[1] ;
10149
10150 if (!args) SWIG_fail;
10151 swig_obj[0] = args;
10152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10153 if (!SWIG_IsOK(res1)) {
10154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10155 }
10156 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10157 {
10158 PyThreadState* __tstate = wxPyBeginAllowThreads();
10159 result = (arg1)->FindNext();
10160 wxPyEndAllowThreads(__tstate);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 {
10164 #if wxUSE_UNICODE
10165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10166 #else
10167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10168 #endif
10169 }
10170 return resultobj;
10171 fail:
10172 return NULL;
10173 }
10174
10175
10176 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10177 PyObject *resultobj = 0;
10178 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10179 wxString *arg2 = 0 ;
10180 wxString result;
10181 void *argp1 = 0 ;
10182 int res1 = 0 ;
10183 bool temp2 = false ;
10184 PyObject * obj0 = 0 ;
10185 PyObject * obj1 = 0 ;
10186 char * kwnames[] = {
10187 (char *) "self",(char *) "location", NULL
10188 };
10189
10190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10194 }
10195 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10196 {
10197 arg2 = wxString_in_helper(obj1);
10198 if (arg2 == NULL) SWIG_fail;
10199 temp2 = true;
10200 }
10201 {
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 result = (arg1)->GetProtocol((wxString const &)*arg2);
10204 wxPyEndAllowThreads(__tstate);
10205 if (PyErr_Occurred()) SWIG_fail;
10206 }
10207 {
10208 #if wxUSE_UNICODE
10209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10210 #else
10211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10212 #endif
10213 }
10214 {
10215 if (temp2)
10216 delete arg2;
10217 }
10218 return resultobj;
10219 fail:
10220 {
10221 if (temp2)
10222 delete arg2;
10223 }
10224 return NULL;
10225 }
10226
10227
10228 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj = 0;
10230 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10231 wxString *arg2 = 0 ;
10232 wxString result;
10233 void *argp1 = 0 ;
10234 int res1 = 0 ;
10235 bool temp2 = false ;
10236 PyObject * obj0 = 0 ;
10237 PyObject * obj1 = 0 ;
10238 char * kwnames[] = {
10239 (char *) "self",(char *) "location", NULL
10240 };
10241
10242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10244 if (!SWIG_IsOK(res1)) {
10245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10246 }
10247 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10248 {
10249 arg2 = wxString_in_helper(obj1);
10250 if (arg2 == NULL) SWIG_fail;
10251 temp2 = true;
10252 }
10253 {
10254 PyThreadState* __tstate = wxPyBeginAllowThreads();
10255 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10256 wxPyEndAllowThreads(__tstate);
10257 if (PyErr_Occurred()) SWIG_fail;
10258 }
10259 {
10260 #if wxUSE_UNICODE
10261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10262 #else
10263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10264 #endif
10265 }
10266 {
10267 if (temp2)
10268 delete arg2;
10269 }
10270 return resultobj;
10271 fail:
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return NULL;
10277 }
10278
10279
10280 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj = 0;
10282 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10283 wxString *arg2 = 0 ;
10284 wxString result;
10285 void *argp1 = 0 ;
10286 int res1 = 0 ;
10287 bool temp2 = false ;
10288 PyObject * obj0 = 0 ;
10289 PyObject * obj1 = 0 ;
10290 char * kwnames[] = {
10291 (char *) "self",(char *) "location", NULL
10292 };
10293
10294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10296 if (!SWIG_IsOK(res1)) {
10297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10298 }
10299 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10300 {
10301 arg2 = wxString_in_helper(obj1);
10302 if (arg2 == NULL) SWIG_fail;
10303 temp2 = true;
10304 }
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 result = (arg1)->GetAnchor((wxString const &)*arg2);
10308 wxPyEndAllowThreads(__tstate);
10309 if (PyErr_Occurred()) SWIG_fail;
10310 }
10311 {
10312 #if wxUSE_UNICODE
10313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10314 #else
10315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10316 #endif
10317 }
10318 {
10319 if (temp2)
10320 delete arg2;
10321 }
10322 return resultobj;
10323 fail:
10324 {
10325 if (temp2)
10326 delete arg2;
10327 }
10328 return NULL;
10329 }
10330
10331
10332 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10333 PyObject *resultobj = 0;
10334 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10335 wxString *arg2 = 0 ;
10336 wxString result;
10337 void *argp1 = 0 ;
10338 int res1 = 0 ;
10339 bool temp2 = false ;
10340 PyObject * obj0 = 0 ;
10341 PyObject * obj1 = 0 ;
10342 char * kwnames[] = {
10343 (char *) "self",(char *) "location", NULL
10344 };
10345
10346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10348 if (!SWIG_IsOK(res1)) {
10349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10350 }
10351 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10352 {
10353 arg2 = wxString_in_helper(obj1);
10354 if (arg2 == NULL) SWIG_fail;
10355 temp2 = true;
10356 }
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10360 wxPyEndAllowThreads(__tstate);
10361 if (PyErr_Occurred()) SWIG_fail;
10362 }
10363 {
10364 #if wxUSE_UNICODE
10365 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10366 #else
10367 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10368 #endif
10369 }
10370 {
10371 if (temp2)
10372 delete arg2;
10373 }
10374 return resultobj;
10375 fail:
10376 {
10377 if (temp2)
10378 delete arg2;
10379 }
10380 return NULL;
10381 }
10382
10383
10384 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj = 0;
10386 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10387 wxString *arg2 = 0 ;
10388 wxString result;
10389 void *argp1 = 0 ;
10390 int res1 = 0 ;
10391 bool temp2 = false ;
10392 PyObject * obj0 = 0 ;
10393 PyObject * obj1 = 0 ;
10394 char * kwnames[] = {
10395 (char *) "self",(char *) "location", NULL
10396 };
10397
10398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10400 if (!SWIG_IsOK(res1)) {
10401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10402 }
10403 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10404 {
10405 arg2 = wxString_in_helper(obj1);
10406 if (arg2 == NULL) SWIG_fail;
10407 temp2 = true;
10408 }
10409 {
10410 PyThreadState* __tstate = wxPyBeginAllowThreads();
10411 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 {
10416 #if wxUSE_UNICODE
10417 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10418 #else
10419 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10420 #endif
10421 }
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return resultobj;
10427 fail:
10428 {
10429 if (temp2)
10430 delete arg2;
10431 }
10432 return NULL;
10433 }
10434
10435
10436 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10437 PyObject *obj;
10438 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10439 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10440 return SWIG_Py_Void();
10441 }
10442
10443 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10444 return SWIG_Python_InitShadowInstance(args);
10445 }
10446
10447 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10448 PyObject *resultobj = 0;
10449 wxFileSystem *result = 0 ;
10450
10451 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 result = (wxFileSystem *)new wxFileSystem();
10455 wxPyEndAllowThreads(__tstate);
10456 if (PyErr_Occurred()) SWIG_fail;
10457 }
10458 {
10459 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10460 }
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10468 PyObject *resultobj = 0;
10469 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10470 void *argp1 = 0 ;
10471 int res1 = 0 ;
10472 PyObject *swig_obj[1] ;
10473
10474 if (!args) SWIG_fail;
10475 swig_obj[0] = args;
10476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10477 if (!SWIG_IsOK(res1)) {
10478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10479 }
10480 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10481 {
10482 PyThreadState* __tstate = wxPyBeginAllowThreads();
10483 delete arg1;
10484
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 resultobj = SWIG_Py_Void();
10489 return resultobj;
10490 fail:
10491 return NULL;
10492 }
10493
10494
10495 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10496 PyObject *resultobj = 0;
10497 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10498 wxString *arg2 = 0 ;
10499 bool arg3 = (bool) false ;
10500 void *argp1 = 0 ;
10501 int res1 = 0 ;
10502 bool temp2 = false ;
10503 bool val3 ;
10504 int ecode3 = 0 ;
10505 PyObject * obj0 = 0 ;
10506 PyObject * obj1 = 0 ;
10507 PyObject * obj2 = 0 ;
10508 char * kwnames[] = {
10509 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10510 };
10511
10512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10514 if (!SWIG_IsOK(res1)) {
10515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10516 }
10517 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10518 {
10519 arg2 = wxString_in_helper(obj1);
10520 if (arg2 == NULL) SWIG_fail;
10521 temp2 = true;
10522 }
10523 if (obj2) {
10524 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10525 if (!SWIG_IsOK(ecode3)) {
10526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10527 }
10528 arg3 = static_cast< bool >(val3);
10529 }
10530 {
10531 PyThreadState* __tstate = wxPyBeginAllowThreads();
10532 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10533 wxPyEndAllowThreads(__tstate);
10534 if (PyErr_Occurred()) SWIG_fail;
10535 }
10536 resultobj = SWIG_Py_Void();
10537 {
10538 if (temp2)
10539 delete arg2;
10540 }
10541 return resultobj;
10542 fail:
10543 {
10544 if (temp2)
10545 delete arg2;
10546 }
10547 return NULL;
10548 }
10549
10550
10551 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10552 PyObject *resultobj = 0;
10553 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10554 wxString result;
10555 void *argp1 = 0 ;
10556 int res1 = 0 ;
10557 PyObject *swig_obj[1] ;
10558
10559 if (!args) SWIG_fail;
10560 swig_obj[0] = args;
10561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10562 if (!SWIG_IsOK(res1)) {
10563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10564 }
10565 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10566 {
10567 PyThreadState* __tstate = wxPyBeginAllowThreads();
10568 result = (arg1)->GetPath();
10569 wxPyEndAllowThreads(__tstate);
10570 if (PyErr_Occurred()) SWIG_fail;
10571 }
10572 {
10573 #if wxUSE_UNICODE
10574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10575 #else
10576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10577 #endif
10578 }
10579 return resultobj;
10580 fail:
10581 return NULL;
10582 }
10583
10584
10585 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj = 0;
10587 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10588 wxString *arg2 = 0 ;
10589 wxFSFile *result = 0 ;
10590 void *argp1 = 0 ;
10591 int res1 = 0 ;
10592 bool temp2 = false ;
10593 PyObject * obj0 = 0 ;
10594 PyObject * obj1 = 0 ;
10595 char * kwnames[] = {
10596 (char *) "self",(char *) "location", NULL
10597 };
10598
10599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10601 if (!SWIG_IsOK(res1)) {
10602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10603 }
10604 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10605 {
10606 arg2 = wxString_in_helper(obj1);
10607 if (arg2 == NULL) SWIG_fail;
10608 temp2 = true;
10609 }
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 {
10617 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10618 }
10619 {
10620 if (temp2)
10621 delete arg2;
10622 }
10623 return resultobj;
10624 fail:
10625 {
10626 if (temp2)
10627 delete arg2;
10628 }
10629 return NULL;
10630 }
10631
10632
10633 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10634 PyObject *resultobj = 0;
10635 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10636 wxString *arg2 = 0 ;
10637 int arg3 = (int) 0 ;
10638 wxString result;
10639 void *argp1 = 0 ;
10640 int res1 = 0 ;
10641 bool temp2 = false ;
10642 int val3 ;
10643 int ecode3 = 0 ;
10644 PyObject * obj0 = 0 ;
10645 PyObject * obj1 = 0 ;
10646 PyObject * obj2 = 0 ;
10647 char * kwnames[] = {
10648 (char *) "self",(char *) "spec",(char *) "flags", NULL
10649 };
10650
10651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10653 if (!SWIG_IsOK(res1)) {
10654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10655 }
10656 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10657 {
10658 arg2 = wxString_in_helper(obj1);
10659 if (arg2 == NULL) SWIG_fail;
10660 temp2 = true;
10661 }
10662 if (obj2) {
10663 ecode3 = SWIG_AsVal_int(obj2, &val3);
10664 if (!SWIG_IsOK(ecode3)) {
10665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10666 }
10667 arg3 = static_cast< int >(val3);
10668 }
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10672 wxPyEndAllowThreads(__tstate);
10673 if (PyErr_Occurred()) SWIG_fail;
10674 }
10675 {
10676 #if wxUSE_UNICODE
10677 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10678 #else
10679 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10680 #endif
10681 }
10682 {
10683 if (temp2)
10684 delete arg2;
10685 }
10686 return resultobj;
10687 fail:
10688 {
10689 if (temp2)
10690 delete arg2;
10691 }
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10697 PyObject *resultobj = 0;
10698 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10699 wxString result;
10700 void *argp1 = 0 ;
10701 int res1 = 0 ;
10702 PyObject *swig_obj[1] ;
10703
10704 if (!args) SWIG_fail;
10705 swig_obj[0] = args;
10706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10707 if (!SWIG_IsOK(res1)) {
10708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10709 }
10710 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10711 {
10712 PyThreadState* __tstate = wxPyBeginAllowThreads();
10713 result = (arg1)->FindNext();
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 {
10718 #if wxUSE_UNICODE
10719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10720 #else
10721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10722 #endif
10723 }
10724 return resultobj;
10725 fail:
10726 return NULL;
10727 }
10728
10729
10730 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10731 PyObject *resultobj = 0;
10732 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10733 int res1 = 0 ;
10734 PyObject * obj0 = 0 ;
10735 char * kwnames[] = {
10736 (char *) "handler", NULL
10737 };
10738
10739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10740 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10741 if (!SWIG_IsOK(res1)) {
10742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10743 }
10744 {
10745 PyThreadState* __tstate = wxPyBeginAllowThreads();
10746 wxFileSystem::AddHandler(arg1);
10747 wxPyEndAllowThreads(__tstate);
10748 if (PyErr_Occurred()) SWIG_fail;
10749 }
10750 resultobj = SWIG_Py_Void();
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10758 PyObject *resultobj = 0;
10759
10760 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 wxFileSystem::CleanUpHandlers();
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_Py_Void();
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj = 0;
10776 wxString *arg1 = 0 ;
10777 wxString result;
10778 bool temp1 = false ;
10779 PyObject * obj0 = 0 ;
10780 char * kwnames[] = {
10781 (char *) "filename", NULL
10782 };
10783
10784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10785 {
10786 arg1 = wxString_in_helper(obj0);
10787 if (arg1 == NULL) SWIG_fail;
10788 temp1 = true;
10789 }
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10793 wxPyEndAllowThreads(__tstate);
10794 if (PyErr_Occurred()) SWIG_fail;
10795 }
10796 {
10797 #if wxUSE_UNICODE
10798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10799 #else
10800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10801 #endif
10802 }
10803 {
10804 if (temp1)
10805 delete arg1;
10806 }
10807 return resultobj;
10808 fail:
10809 {
10810 if (temp1)
10811 delete arg1;
10812 }
10813 return NULL;
10814 }
10815
10816
10817 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj = 0;
10819 wxString *arg1 = 0 ;
10820 wxString result;
10821 bool temp1 = false ;
10822 PyObject * obj0 = 0 ;
10823 char * kwnames[] = {
10824 (char *) "url", NULL
10825 };
10826
10827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10828 {
10829 arg1 = wxString_in_helper(obj0);
10830 if (arg1 == NULL) SWIG_fail;
10831 temp1 = true;
10832 }
10833 {
10834 PyThreadState* __tstate = wxPyBeginAllowThreads();
10835 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 {
10840 #if wxUSE_UNICODE
10841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10842 #else
10843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10844 #endif
10845 }
10846 {
10847 if (temp1)
10848 delete arg1;
10849 }
10850 return resultobj;
10851 fail:
10852 {
10853 if (temp1)
10854 delete arg1;
10855 }
10856 return NULL;
10857 }
10858
10859
10860 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10861 PyObject *obj;
10862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10863 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10864 return SWIG_Py_Void();
10865 }
10866
10867 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10868 return SWIG_Python_InitShadowInstance(args);
10869 }
10870
10871 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10872 PyObject *resultobj = 0;
10873 wxInternetFSHandler *result = 0 ;
10874
10875 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10879 wxPyEndAllowThreads(__tstate);
10880 if (PyErr_Occurred()) SWIG_fail;
10881 }
10882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10883 return resultobj;
10884 fail:
10885 return NULL;
10886 }
10887
10888
10889 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10890 PyObject *resultobj = 0;
10891 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10892 wxString *arg2 = 0 ;
10893 bool result;
10894 void *argp1 = 0 ;
10895 int res1 = 0 ;
10896 bool temp2 = false ;
10897 PyObject * obj0 = 0 ;
10898 PyObject * obj1 = 0 ;
10899 char * kwnames[] = {
10900 (char *) "self",(char *) "location", NULL
10901 };
10902
10903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10905 if (!SWIG_IsOK(res1)) {
10906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10907 }
10908 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10909 {
10910 arg2 = wxString_in_helper(obj1);
10911 if (arg2 == NULL) SWIG_fail;
10912 temp2 = true;
10913 }
10914 {
10915 PyThreadState* __tstate = wxPyBeginAllowThreads();
10916 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10917 wxPyEndAllowThreads(__tstate);
10918 if (PyErr_Occurred()) SWIG_fail;
10919 }
10920 {
10921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10922 }
10923 {
10924 if (temp2)
10925 delete arg2;
10926 }
10927 return resultobj;
10928 fail:
10929 {
10930 if (temp2)
10931 delete arg2;
10932 }
10933 return NULL;
10934 }
10935
10936
10937 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10938 PyObject *resultobj = 0;
10939 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10940 wxFileSystem *arg2 = 0 ;
10941 wxString *arg3 = 0 ;
10942 wxFSFile *result = 0 ;
10943 void *argp1 = 0 ;
10944 int res1 = 0 ;
10945 void *argp2 = 0 ;
10946 int res2 = 0 ;
10947 bool temp3 = false ;
10948 PyObject * obj0 = 0 ;
10949 PyObject * obj1 = 0 ;
10950 PyObject * obj2 = 0 ;
10951 char * kwnames[] = {
10952 (char *) "self",(char *) "fs",(char *) "location", NULL
10953 };
10954
10955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10957 if (!SWIG_IsOK(res1)) {
10958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10959 }
10960 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10962 if (!SWIG_IsOK(res2)) {
10963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10964 }
10965 if (!argp2) {
10966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10967 }
10968 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10969 {
10970 arg3 = wxString_in_helper(obj2);
10971 if (arg3 == NULL) SWIG_fail;
10972 temp3 = true;
10973 }
10974 {
10975 PyThreadState* __tstate = wxPyBeginAllowThreads();
10976 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10977 wxPyEndAllowThreads(__tstate);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 {
10981 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10982 }
10983 {
10984 if (temp3)
10985 delete arg3;
10986 }
10987 return resultobj;
10988 fail:
10989 {
10990 if (temp3)
10991 delete arg3;
10992 }
10993 return NULL;
10994 }
10995
10996
10997 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10998 PyObject *obj;
10999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11000 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11001 return SWIG_Py_Void();
11002 }
11003
11004 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11005 return SWIG_Python_InitShadowInstance(args);
11006 }
11007
11008 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11009 PyObject *resultobj = 0;
11010 wxZipFSHandler *result = 0 ;
11011
11012 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (wxZipFSHandler *)new wxZipFSHandler();
11016 wxPyEndAllowThreads(__tstate);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11027 PyObject *resultobj = 0;
11028 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11029 wxString *arg2 = 0 ;
11030 bool result;
11031 void *argp1 = 0 ;
11032 int res1 = 0 ;
11033 bool temp2 = false ;
11034 PyObject * obj0 = 0 ;
11035 PyObject * obj1 = 0 ;
11036 char * kwnames[] = {
11037 (char *) "self",(char *) "location", NULL
11038 };
11039
11040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11042 if (!SWIG_IsOK(res1)) {
11043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11044 }
11045 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11046 {
11047 arg2 = wxString_in_helper(obj1);
11048 if (arg2 == NULL) SWIG_fail;
11049 temp2 = true;
11050 }
11051 {
11052 PyThreadState* __tstate = wxPyBeginAllowThreads();
11053 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11054 wxPyEndAllowThreads(__tstate);
11055 if (PyErr_Occurred()) SWIG_fail;
11056 }
11057 {
11058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11059 }
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return resultobj;
11065 fail:
11066 {
11067 if (temp2)
11068 delete arg2;
11069 }
11070 return NULL;
11071 }
11072
11073
11074 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj = 0;
11076 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11077 wxFileSystem *arg2 = 0 ;
11078 wxString *arg3 = 0 ;
11079 wxFSFile *result = 0 ;
11080 void *argp1 = 0 ;
11081 int res1 = 0 ;
11082 void *argp2 = 0 ;
11083 int res2 = 0 ;
11084 bool temp3 = false ;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 PyObject * obj2 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "fs",(char *) "location", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11096 }
11097 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11099 if (!SWIG_IsOK(res2)) {
11100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11101 }
11102 if (!argp2) {
11103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11104 }
11105 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11106 {
11107 arg3 = wxString_in_helper(obj2);
11108 if (arg3 == NULL) SWIG_fail;
11109 temp3 = true;
11110 }
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11114 wxPyEndAllowThreads(__tstate);
11115 if (PyErr_Occurred()) SWIG_fail;
11116 }
11117 {
11118 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11119 }
11120 {
11121 if (temp3)
11122 delete arg3;
11123 }
11124 return resultobj;
11125 fail:
11126 {
11127 if (temp3)
11128 delete arg3;
11129 }
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11135 PyObject *resultobj = 0;
11136 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11137 wxString *arg2 = 0 ;
11138 int arg3 = (int) 0 ;
11139 wxString result;
11140 void *argp1 = 0 ;
11141 int res1 = 0 ;
11142 bool temp2 = false ;
11143 int val3 ;
11144 int ecode3 = 0 ;
11145 PyObject * obj0 = 0 ;
11146 PyObject * obj1 = 0 ;
11147 PyObject * obj2 = 0 ;
11148 char * kwnames[] = {
11149 (char *) "self",(char *) "spec",(char *) "flags", NULL
11150 };
11151
11152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11154 if (!SWIG_IsOK(res1)) {
11155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11156 }
11157 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11158 {
11159 arg2 = wxString_in_helper(obj1);
11160 if (arg2 == NULL) SWIG_fail;
11161 temp2 = true;
11162 }
11163 if (obj2) {
11164 ecode3 = SWIG_AsVal_int(obj2, &val3);
11165 if (!SWIG_IsOK(ecode3)) {
11166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11167 }
11168 arg3 = static_cast< int >(val3);
11169 }
11170 {
11171 PyThreadState* __tstate = wxPyBeginAllowThreads();
11172 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11173 wxPyEndAllowThreads(__tstate);
11174 if (PyErr_Occurred()) SWIG_fail;
11175 }
11176 {
11177 #if wxUSE_UNICODE
11178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11179 #else
11180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11181 #endif
11182 }
11183 {
11184 if (temp2)
11185 delete arg2;
11186 }
11187 return resultobj;
11188 fail:
11189 {
11190 if (temp2)
11191 delete arg2;
11192 }
11193 return NULL;
11194 }
11195
11196
11197 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11198 PyObject *resultobj = 0;
11199 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11200 wxString result;
11201 void *argp1 = 0 ;
11202 int res1 = 0 ;
11203 PyObject *swig_obj[1] ;
11204
11205 if (!args) SWIG_fail;
11206 swig_obj[0] = args;
11207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11208 if (!SWIG_IsOK(res1)) {
11209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11210 }
11211 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11212 {
11213 PyThreadState* __tstate = wxPyBeginAllowThreads();
11214 result = (arg1)->FindNext();
11215 wxPyEndAllowThreads(__tstate);
11216 if (PyErr_Occurred()) SWIG_fail;
11217 }
11218 {
11219 #if wxUSE_UNICODE
11220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11221 #else
11222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11223 #endif
11224 }
11225 return resultobj;
11226 fail:
11227 return NULL;
11228 }
11229
11230
11231 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11232 PyObject *obj;
11233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11234 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11235 return SWIG_Py_Void();
11236 }
11237
11238 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11239 return SWIG_Python_InitShadowInstance(args);
11240 }
11241
11242 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = 0;
11244 wxString *arg1 = 0 ;
11245 wxImage *arg2 = 0 ;
11246 long arg3 ;
11247 bool temp1 = false ;
11248 void *argp2 = 0 ;
11249 int res2 = 0 ;
11250 long val3 ;
11251 int ecode3 = 0 ;
11252 PyObject * obj0 = 0 ;
11253 PyObject * obj1 = 0 ;
11254 PyObject * obj2 = 0 ;
11255 char * kwnames[] = {
11256 (char *) "filename",(char *) "image",(char *) "type", NULL
11257 };
11258
11259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11260 {
11261 arg1 = wxString_in_helper(obj0);
11262 if (arg1 == NULL) SWIG_fail;
11263 temp1 = true;
11264 }
11265 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11266 if (!SWIG_IsOK(res2)) {
11267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11268 }
11269 if (!argp2) {
11270 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11271 }
11272 arg2 = reinterpret_cast< wxImage * >(argp2);
11273 ecode3 = SWIG_AsVal_long(obj2, &val3);
11274 if (!SWIG_IsOK(ecode3)) {
11275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11276 }
11277 arg3 = static_cast< long >(val3);
11278 {
11279 PyThreadState* __tstate = wxPyBeginAllowThreads();
11280 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11281 wxPyEndAllowThreads(__tstate);
11282 if (PyErr_Occurred()) SWIG_fail;
11283 }
11284 resultobj = SWIG_Py_Void();
11285 {
11286 if (temp1)
11287 delete arg1;
11288 }
11289 return resultobj;
11290 fail:
11291 {
11292 if (temp1)
11293 delete arg1;
11294 }
11295 return NULL;
11296 }
11297
11298
11299 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 wxString *arg1 = 0 ;
11302 wxBitmap *arg2 = 0 ;
11303 long arg3 ;
11304 bool temp1 = false ;
11305 void *argp2 = 0 ;
11306 int res2 = 0 ;
11307 long val3 ;
11308 int ecode3 = 0 ;
11309 PyObject * obj0 = 0 ;
11310 PyObject * obj1 = 0 ;
11311 PyObject * obj2 = 0 ;
11312 char * kwnames[] = {
11313 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11314 };
11315
11316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11317 {
11318 arg1 = wxString_in_helper(obj0);
11319 if (arg1 == NULL) SWIG_fail;
11320 temp1 = true;
11321 }
11322 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11323 if (!SWIG_IsOK(res2)) {
11324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11325 }
11326 if (!argp2) {
11327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11328 }
11329 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11330 ecode3 = SWIG_AsVal_long(obj2, &val3);
11331 if (!SWIG_IsOK(ecode3)) {
11332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11333 }
11334 arg3 = static_cast< long >(val3);
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxString *arg1 = 0 ;
11359 PyObject *arg2 = (PyObject *) 0 ;
11360 bool temp1 = false ;
11361 PyObject * obj0 = 0 ;
11362 PyObject * obj1 = 0 ;
11363 char * kwnames[] = {
11364 (char *) "filename",(char *) "data", NULL
11365 };
11366
11367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11368 {
11369 arg1 = wxString_in_helper(obj0);
11370 if (arg1 == NULL) SWIG_fail;
11371 temp1 = true;
11372 }
11373 arg2 = obj1;
11374 {
11375 PyThreadState* __tstate = wxPyBeginAllowThreads();
11376 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 resultobj = SWIG_Py_Void();
11381 {
11382 if (temp1)
11383 delete arg1;
11384 }
11385 return resultobj;
11386 fail:
11387 {
11388 if (temp1)
11389 delete arg1;
11390 }
11391 return NULL;
11392 }
11393
11394
11395 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11396 PyObject *resultobj = 0;
11397 wxMemoryFSHandler *result = 0 ;
11398
11399 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11400 {
11401 PyThreadState* __tstate = wxPyBeginAllowThreads();
11402 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11403 wxPyEndAllowThreads(__tstate);
11404 if (PyErr_Occurred()) SWIG_fail;
11405 }
11406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11407 return resultobj;
11408 fail:
11409 return NULL;
11410 }
11411
11412
11413 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11414 PyObject *resultobj = 0;
11415 wxString *arg1 = 0 ;
11416 bool temp1 = false ;
11417 PyObject * obj0 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "filename", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11423 {
11424 arg1 = wxString_in_helper(obj0);
11425 if (arg1 == NULL) SWIG_fail;
11426 temp1 = true;
11427 }
11428 {
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 resultobj = SWIG_Py_Void();
11435 {
11436 if (temp1)
11437 delete arg1;
11438 }
11439 return resultobj;
11440 fail:
11441 {
11442 if (temp1)
11443 delete arg1;
11444 }
11445 return NULL;
11446 }
11447
11448
11449 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11450 PyObject *resultobj = 0;
11451 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11452 wxString *arg2 = 0 ;
11453 bool result;
11454 void *argp1 = 0 ;
11455 int res1 = 0 ;
11456 bool temp2 = false ;
11457 PyObject * obj0 = 0 ;
11458 PyObject * obj1 = 0 ;
11459 char * kwnames[] = {
11460 (char *) "self",(char *) "location", NULL
11461 };
11462
11463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11465 if (!SWIG_IsOK(res1)) {
11466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11467 }
11468 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11469 {
11470 arg2 = wxString_in_helper(obj1);
11471 if (arg2 == NULL) SWIG_fail;
11472 temp2 = true;
11473 }
11474 {
11475 PyThreadState* __tstate = wxPyBeginAllowThreads();
11476 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11477 wxPyEndAllowThreads(__tstate);
11478 if (PyErr_Occurred()) SWIG_fail;
11479 }
11480 {
11481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11482 }
11483 {
11484 if (temp2)
11485 delete arg2;
11486 }
11487 return resultobj;
11488 fail:
11489 {
11490 if (temp2)
11491 delete arg2;
11492 }
11493 return NULL;
11494 }
11495
11496
11497 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11498 PyObject *resultobj = 0;
11499 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11500 wxFileSystem *arg2 = 0 ;
11501 wxString *arg3 = 0 ;
11502 wxFSFile *result = 0 ;
11503 void *argp1 = 0 ;
11504 int res1 = 0 ;
11505 void *argp2 = 0 ;
11506 int res2 = 0 ;
11507 bool temp3 = false ;
11508 PyObject * obj0 = 0 ;
11509 PyObject * obj1 = 0 ;
11510 PyObject * obj2 = 0 ;
11511 char * kwnames[] = {
11512 (char *) "self",(char *) "fs",(char *) "location", NULL
11513 };
11514
11515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11517 if (!SWIG_IsOK(res1)) {
11518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11519 }
11520 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11522 if (!SWIG_IsOK(res2)) {
11523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11524 }
11525 if (!argp2) {
11526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11527 }
11528 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11529 {
11530 arg3 = wxString_in_helper(obj2);
11531 if (arg3 == NULL) SWIG_fail;
11532 temp3 = true;
11533 }
11534 {
11535 PyThreadState* __tstate = wxPyBeginAllowThreads();
11536 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11537 wxPyEndAllowThreads(__tstate);
11538 if (PyErr_Occurred()) SWIG_fail;
11539 }
11540 {
11541 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11542 }
11543 {
11544 if (temp3)
11545 delete arg3;
11546 }
11547 return resultobj;
11548 fail:
11549 {
11550 if (temp3)
11551 delete arg3;
11552 }
11553 return NULL;
11554 }
11555
11556
11557 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj = 0;
11559 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11560 wxString *arg2 = 0 ;
11561 int arg3 = (int) 0 ;
11562 wxString result;
11563 void *argp1 = 0 ;
11564 int res1 = 0 ;
11565 bool temp2 = false ;
11566 int val3 ;
11567 int ecode3 = 0 ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 char * kwnames[] = {
11572 (char *) "self",(char *) "spec",(char *) "flags", NULL
11573 };
11574
11575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11577 if (!SWIG_IsOK(res1)) {
11578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11579 }
11580 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11581 {
11582 arg2 = wxString_in_helper(obj1);
11583 if (arg2 == NULL) SWIG_fail;
11584 temp2 = true;
11585 }
11586 if (obj2) {
11587 ecode3 = SWIG_AsVal_int(obj2, &val3);
11588 if (!SWIG_IsOK(ecode3)) {
11589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11590 }
11591 arg3 = static_cast< int >(val3);
11592 }
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 {
11600 #if wxUSE_UNICODE
11601 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11602 #else
11603 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11604 #endif
11605 }
11606 {
11607 if (temp2)
11608 delete arg2;
11609 }
11610 return resultobj;
11611 fail:
11612 {
11613 if (temp2)
11614 delete arg2;
11615 }
11616 return NULL;
11617 }
11618
11619
11620 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11621 PyObject *resultobj = 0;
11622 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11623 wxString result;
11624 void *argp1 = 0 ;
11625 int res1 = 0 ;
11626 PyObject *swig_obj[1] ;
11627
11628 if (!args) SWIG_fail;
11629 swig_obj[0] = args;
11630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11631 if (!SWIG_IsOK(res1)) {
11632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11633 }
11634 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11635 {
11636 PyThreadState* __tstate = wxPyBeginAllowThreads();
11637 result = (arg1)->FindNext();
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 #if wxUSE_UNICODE
11643 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11644 #else
11645 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11646 #endif
11647 }
11648 return resultobj;
11649 fail:
11650 return NULL;
11651 }
11652
11653
11654 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11655 PyObject *obj;
11656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11657 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11658 return SWIG_Py_Void();
11659 }
11660
11661 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11662 return SWIG_Python_InitShadowInstance(args);
11663 }
11664
11665 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11666 PyObject *resultobj = 0;
11667 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11668 wxString result;
11669 void *argp1 = 0 ;
11670 int res1 = 0 ;
11671 PyObject *swig_obj[1] ;
11672
11673 if (!args) SWIG_fail;
11674 swig_obj[0] = args;
11675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11676 if (!SWIG_IsOK(res1)) {
11677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11678 }
11679 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11680 {
11681 PyThreadState* __tstate = wxPyBeginAllowThreads();
11682 result = (arg1)->GetName();
11683 wxPyEndAllowThreads(__tstate);
11684 if (PyErr_Occurred()) SWIG_fail;
11685 }
11686 {
11687 #if wxUSE_UNICODE
11688 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11689 #else
11690 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11691 #endif
11692 }
11693 return resultobj;
11694 fail:
11695 return NULL;
11696 }
11697
11698
11699 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11700 PyObject *resultobj = 0;
11701 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11702 wxString result;
11703 void *argp1 = 0 ;
11704 int res1 = 0 ;
11705 PyObject *swig_obj[1] ;
11706
11707 if (!args) SWIG_fail;
11708 swig_obj[0] = args;
11709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11710 if (!SWIG_IsOK(res1)) {
11711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11712 }
11713 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11714 {
11715 PyThreadState* __tstate = wxPyBeginAllowThreads();
11716 result = (arg1)->GetExtension();
11717 wxPyEndAllowThreads(__tstate);
11718 if (PyErr_Occurred()) SWIG_fail;
11719 }
11720 {
11721 #if wxUSE_UNICODE
11722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11723 #else
11724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11725 #endif
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11734 PyObject *resultobj = 0;
11735 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11736 long result;
11737 void *argp1 = 0 ;
11738 int res1 = 0 ;
11739 PyObject *swig_obj[1] ;
11740
11741 if (!args) SWIG_fail;
11742 swig_obj[0] = args;
11743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11746 }
11747 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11748 {
11749 PyThreadState* __tstate = wxPyBeginAllowThreads();
11750 result = (long)(arg1)->GetType();
11751 wxPyEndAllowThreads(__tstate);
11752 if (PyErr_Occurred()) SWIG_fail;
11753 }
11754 resultobj = SWIG_From_long(static_cast< long >(result));
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11762 PyObject *resultobj = 0;
11763 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11764 wxString result;
11765 void *argp1 = 0 ;
11766 int res1 = 0 ;
11767 PyObject *swig_obj[1] ;
11768
11769 if (!args) SWIG_fail;
11770 swig_obj[0] = args;
11771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11772 if (!SWIG_IsOK(res1)) {
11773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11774 }
11775 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 result = (arg1)->GetMimeType();
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 #if wxUSE_UNICODE
11784 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11785 #else
11786 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11787 #endif
11788 }
11789 return resultobj;
11790 fail:
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj = 0;
11797 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11798 wxString *arg2 = 0 ;
11799 bool result;
11800 void *argp1 = 0 ;
11801 int res1 = 0 ;
11802 bool temp2 = false ;
11803 PyObject * obj0 = 0 ;
11804 PyObject * obj1 = 0 ;
11805 char * kwnames[] = {
11806 (char *) "self",(char *) "name", NULL
11807 };
11808
11809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11811 if (!SWIG_IsOK(res1)) {
11812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11813 }
11814 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11815 {
11816 arg2 = wxString_in_helper(obj1);
11817 if (arg2 == NULL) SWIG_fail;
11818 temp2 = true;
11819 }
11820 {
11821 PyThreadState* __tstate = wxPyBeginAllowThreads();
11822 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11823 wxPyEndAllowThreads(__tstate);
11824 if (PyErr_Occurred()) SWIG_fail;
11825 }
11826 {
11827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11828 }
11829 {
11830 if (temp2)
11831 delete arg2;
11832 }
11833 return resultobj;
11834 fail:
11835 {
11836 if (temp2)
11837 delete arg2;
11838 }
11839 return NULL;
11840 }
11841
11842
11843 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11844 PyObject *resultobj = 0;
11845 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11846 wxString *arg2 = 0 ;
11847 void *argp1 = 0 ;
11848 int res1 = 0 ;
11849 bool temp2 = false ;
11850 PyObject * obj0 = 0 ;
11851 PyObject * obj1 = 0 ;
11852 char * kwnames[] = {
11853 (char *) "self",(char *) "name", NULL
11854 };
11855
11856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11858 if (!SWIG_IsOK(res1)) {
11859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11860 }
11861 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11862 {
11863 arg2 = wxString_in_helper(obj1);
11864 if (arg2 == NULL) SWIG_fail;
11865 temp2 = true;
11866 }
11867 {
11868 PyThreadState* __tstate = wxPyBeginAllowThreads();
11869 (arg1)->SetName((wxString const &)*arg2);
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 resultobj = SWIG_Py_Void();
11874 {
11875 if (temp2)
11876 delete arg2;
11877 }
11878 return resultobj;
11879 fail:
11880 {
11881 if (temp2)
11882 delete arg2;
11883 }
11884 return NULL;
11885 }
11886
11887
11888 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj = 0;
11890 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11891 wxString *arg2 = 0 ;
11892 void *argp1 = 0 ;
11893 int res1 = 0 ;
11894 bool temp2 = false ;
11895 PyObject * obj0 = 0 ;
11896 PyObject * obj1 = 0 ;
11897 char * kwnames[] = {
11898 (char *) "self",(char *) "extension", NULL
11899 };
11900
11901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11905 }
11906 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11907 {
11908 arg2 = wxString_in_helper(obj1);
11909 if (arg2 == NULL) SWIG_fail;
11910 temp2 = true;
11911 }
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 (arg1)->SetExtension((wxString const &)*arg2);
11915 wxPyEndAllowThreads(__tstate);
11916 if (PyErr_Occurred()) SWIG_fail;
11917 }
11918 resultobj = SWIG_Py_Void();
11919 {
11920 if (temp2)
11921 delete arg2;
11922 }
11923 return resultobj;
11924 fail:
11925 {
11926 if (temp2)
11927 delete arg2;
11928 }
11929 return NULL;
11930 }
11931
11932
11933 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj = 0;
11935 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11936 long arg2 ;
11937 void *argp1 = 0 ;
11938 int res1 = 0 ;
11939 long val2 ;
11940 int ecode2 = 0 ;
11941 PyObject * obj0 = 0 ;
11942 PyObject * obj1 = 0 ;
11943 char * kwnames[] = {
11944 (char *) "self",(char *) "type", NULL
11945 };
11946
11947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11949 if (!SWIG_IsOK(res1)) {
11950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11951 }
11952 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11953 ecode2 = SWIG_AsVal_long(obj1, &val2);
11954 if (!SWIG_IsOK(ecode2)) {
11955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11956 }
11957 arg2 = static_cast< long >(val2);
11958 {
11959 PyThreadState* __tstate = wxPyBeginAllowThreads();
11960 (arg1)->SetType(arg2);
11961 wxPyEndAllowThreads(__tstate);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 resultobj = SWIG_Py_Void();
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj = 0;
11973 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11974 wxString *arg2 = 0 ;
11975 void *argp1 = 0 ;
11976 int res1 = 0 ;
11977 bool temp2 = false ;
11978 PyObject * obj0 = 0 ;
11979 PyObject * obj1 = 0 ;
11980 char * kwnames[] = {
11981 (char *) "self",(char *) "mimetype", NULL
11982 };
11983
11984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11986 if (!SWIG_IsOK(res1)) {
11987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11988 }
11989 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11990 {
11991 arg2 = wxString_in_helper(obj1);
11992 if (arg2 == NULL) SWIG_fail;
11993 temp2 = true;
11994 }
11995 {
11996 PyThreadState* __tstate = wxPyBeginAllowThreads();
11997 (arg1)->SetMimeType((wxString const &)*arg2);
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 resultobj = SWIG_Py_Void();
12002 {
12003 if (temp2)
12004 delete arg2;
12005 }
12006 return resultobj;
12007 fail:
12008 {
12009 if (temp2)
12010 delete arg2;
12011 }
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12017 PyObject *obj;
12018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12019 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12020 return SWIG_Py_Void();
12021 }
12022
12023 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12024 PyObject *resultobj = 0;
12025 wxPyImageHandler *result = 0 ;
12026
12027 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12028 {
12029 PyThreadState* __tstate = wxPyBeginAllowThreads();
12030 result = (wxPyImageHandler *)new wxPyImageHandler();
12031 wxPyEndAllowThreads(__tstate);
12032 if (PyErr_Occurred()) SWIG_fail;
12033 }
12034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12035 return resultobj;
12036 fail:
12037 return NULL;
12038 }
12039
12040
12041 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12042 PyObject *resultobj = 0;
12043 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12044 PyObject *arg2 = (PyObject *) 0 ;
12045 void *argp1 = 0 ;
12046 int res1 = 0 ;
12047 PyObject * obj0 = 0 ;
12048 PyObject * obj1 = 0 ;
12049 char * kwnames[] = {
12050 (char *) "self",(char *) "self", NULL
12051 };
12052
12053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12055 if (!SWIG_IsOK(res1)) {
12056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12057 }
12058 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12059 arg2 = obj1;
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 (arg1)->_SetSelf(arg2);
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 resultobj = SWIG_Py_Void();
12067 return resultobj;
12068 fail:
12069 return NULL;
12070 }
12071
12072
12073 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12074 PyObject *obj;
12075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12076 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12077 return SWIG_Py_Void();
12078 }
12079
12080 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12081 return SWIG_Python_InitShadowInstance(args);
12082 }
12083
12084 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *resultobj = 0;
12086 wxImageHistogram *result = 0 ;
12087
12088 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 result = (wxImageHistogram *)new wxImageHistogram();
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12096 return resultobj;
12097 fail:
12098 return NULL;
12099 }
12100
12101
12102 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12103 PyObject *resultobj = 0;
12104 byte arg1 ;
12105 byte arg2 ;
12106 byte arg3 ;
12107 unsigned long result;
12108 unsigned char val1 ;
12109 int ecode1 = 0 ;
12110 unsigned char val2 ;
12111 int ecode2 = 0 ;
12112 unsigned char val3 ;
12113 int ecode3 = 0 ;
12114 PyObject * obj0 = 0 ;
12115 PyObject * obj1 = 0 ;
12116 PyObject * obj2 = 0 ;
12117 char * kwnames[] = {
12118 (char *) "r",(char *) "g",(char *) "b", NULL
12119 };
12120
12121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12122 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12123 if (!SWIG_IsOK(ecode1)) {
12124 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12125 }
12126 arg1 = static_cast< byte >(val1);
12127 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12128 if (!SWIG_IsOK(ecode2)) {
12129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12130 }
12131 arg2 = static_cast< byte >(val2);
12132 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12133 if (!SWIG_IsOK(ecode3)) {
12134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12135 }
12136 arg3 = static_cast< byte >(val3);
12137 {
12138 PyThreadState* __tstate = wxPyBeginAllowThreads();
12139 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12144 return resultobj;
12145 fail:
12146 return NULL;
12147 }
12148
12149
12150 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12151 PyObject *resultobj = 0;
12152 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12153 byte *arg2 = (byte *) 0 ;
12154 byte *arg3 = (byte *) 0 ;
12155 byte *arg4 = (byte *) 0 ;
12156 byte arg5 = (byte) 1 ;
12157 byte arg6 = (byte) 0 ;
12158 byte arg7 = (byte) 0 ;
12159 bool result;
12160 void *argp1 = 0 ;
12161 int res1 = 0 ;
12162 byte temp2 ;
12163 int res2 = SWIG_TMPOBJ ;
12164 byte temp3 ;
12165 int res3 = SWIG_TMPOBJ ;
12166 byte temp4 ;
12167 int res4 = SWIG_TMPOBJ ;
12168 unsigned char val5 ;
12169 int ecode5 = 0 ;
12170 unsigned char val6 ;
12171 int ecode6 = 0 ;
12172 unsigned char val7 ;
12173 int ecode7 = 0 ;
12174 PyObject * obj0 = 0 ;
12175 PyObject * obj1 = 0 ;
12176 PyObject * obj2 = 0 ;
12177 PyObject * obj3 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12180 };
12181
12182 arg2 = &temp2;
12183 arg3 = &temp3;
12184 arg4 = &temp4;
12185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12187 if (!SWIG_IsOK(res1)) {
12188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12189 }
12190 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12191 if (obj1) {
12192 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12193 if (!SWIG_IsOK(ecode5)) {
12194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12195 }
12196 arg5 = static_cast< byte >(val5);
12197 }
12198 if (obj2) {
12199 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12200 if (!SWIG_IsOK(ecode6)) {
12201 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12202 }
12203 arg6 = static_cast< byte >(val6);
12204 }
12205 if (obj3) {
12206 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12207 if (!SWIG_IsOK(ecode7)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12209 }
12210 arg7 = static_cast< byte >(val7);
12211 }
12212 {
12213 PyThreadState* __tstate = wxPyBeginAllowThreads();
12214 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12220 }
12221 if (SWIG_IsTmpObj(res2)) {
12222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12223 } else {
12224 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12226 }
12227 if (SWIG_IsTmpObj(res3)) {
12228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12229 } else {
12230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12232 }
12233 if (SWIG_IsTmpObj(res4)) {
12234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12235 } else {
12236 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12238 }
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj = 0;
12247 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12248 unsigned long arg2 ;
12249 unsigned long result;
12250 void *argp1 = 0 ;
12251 int res1 = 0 ;
12252 unsigned long val2 ;
12253 int ecode2 = 0 ;
12254 PyObject * obj0 = 0 ;
12255 PyObject * obj1 = 0 ;
12256 char * kwnames[] = {
12257 (char *) "self",(char *) "key", NULL
12258 };
12259
12260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12262 if (!SWIG_IsOK(res1)) {
12263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12264 }
12265 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12266 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12267 if (!SWIG_IsOK(ecode2)) {
12268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12269 }
12270 arg2 = static_cast< unsigned long >(val2);
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12274 wxPyEndAllowThreads(__tstate);
12275 if (PyErr_Occurred()) SWIG_fail;
12276 }
12277 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12278 return resultobj;
12279 fail:
12280 return NULL;
12281 }
12282
12283
12284 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj = 0;
12286 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12287 byte arg2 ;
12288 byte arg3 ;
12289 byte arg4 ;
12290 unsigned long result;
12291 void *argp1 = 0 ;
12292 int res1 = 0 ;
12293 unsigned char val2 ;
12294 int ecode2 = 0 ;
12295 unsigned char val3 ;
12296 int ecode3 = 0 ;
12297 unsigned char val4 ;
12298 int ecode4 = 0 ;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 PyObject * obj2 = 0 ;
12302 PyObject * obj3 = 0 ;
12303 char * kwnames[] = {
12304 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12305 };
12306
12307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12309 if (!SWIG_IsOK(res1)) {
12310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12311 }
12312 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12313 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12314 if (!SWIG_IsOK(ecode2)) {
12315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12316 }
12317 arg2 = static_cast< byte >(val2);
12318 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12319 if (!SWIG_IsOK(ecode3)) {
12320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12321 }
12322 arg3 = static_cast< byte >(val3);
12323 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12324 if (!SWIG_IsOK(ecode4)) {
12325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12326 }
12327 arg4 = static_cast< byte >(val4);
12328 {
12329 PyThreadState* __tstate = wxPyBeginAllowThreads();
12330 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12331 wxPyEndAllowThreads(__tstate);
12332 if (PyErr_Occurred()) SWIG_fail;
12333 }
12334 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12335 return resultobj;
12336 fail:
12337 return NULL;
12338 }
12339
12340
12341 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12342 PyObject *resultobj = 0;
12343 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12344 wxColour *arg2 = 0 ;
12345 unsigned long result;
12346 void *argp1 = 0 ;
12347 int res1 = 0 ;
12348 wxColour temp2 ;
12349 PyObject * obj0 = 0 ;
12350 PyObject * obj1 = 0 ;
12351 char * kwnames[] = {
12352 (char *) "self",(char *) "colour", NULL
12353 };
12354
12355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12357 if (!SWIG_IsOK(res1)) {
12358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12359 }
12360 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12361 {
12362 arg2 = &temp2;
12363 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12364 }
12365 {
12366 PyThreadState* __tstate = wxPyBeginAllowThreads();
12367 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12368 wxPyEndAllowThreads(__tstate);
12369 if (PyErr_Occurred()) SWIG_fail;
12370 }
12371 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12372 return resultobj;
12373 fail:
12374 return NULL;
12375 }
12376
12377
12378 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12379 PyObject *obj;
12380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12381 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12382 return SWIG_Py_Void();
12383 }
12384
12385 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12386 return SWIG_Python_InitShadowInstance(args);
12387 }
12388
12389 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj = 0;
12391 byte arg1 = (byte) 0 ;
12392 byte arg2 = (byte) 0 ;
12393 byte arg3 = (byte) 0 ;
12394 wxImage_RGBValue *result = 0 ;
12395 unsigned char val1 ;
12396 int ecode1 = 0 ;
12397 unsigned char val2 ;
12398 int ecode2 = 0 ;
12399 unsigned char val3 ;
12400 int ecode3 = 0 ;
12401 PyObject * obj0 = 0 ;
12402 PyObject * obj1 = 0 ;
12403 PyObject * obj2 = 0 ;
12404 char * kwnames[] = {
12405 (char *) "r",(char *) "g",(char *) "b", NULL
12406 };
12407
12408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12409 if (obj0) {
12410 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12411 if (!SWIG_IsOK(ecode1)) {
12412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12413 }
12414 arg1 = static_cast< byte >(val1);
12415 }
12416 if (obj1) {
12417 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12418 if (!SWIG_IsOK(ecode2)) {
12419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12420 }
12421 arg2 = static_cast< byte >(val2);
12422 }
12423 if (obj2) {
12424 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12425 if (!SWIG_IsOK(ecode3)) {
12426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12427 }
12428 arg3 = static_cast< byte >(val3);
12429 }
12430 {
12431 PyThreadState* __tstate = wxPyBeginAllowThreads();
12432 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12433 wxPyEndAllowThreads(__tstate);
12434 if (PyErr_Occurred()) SWIG_fail;
12435 }
12436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12437 return resultobj;
12438 fail:
12439 return NULL;
12440 }
12441
12442
12443 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 PyObject *resultobj = 0;
12445 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12446 byte arg2 ;
12447 void *argp1 = 0 ;
12448 int res1 = 0 ;
12449 unsigned char val2 ;
12450 int ecode2 = 0 ;
12451 PyObject *swig_obj[2] ;
12452
12453 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12455 if (!SWIG_IsOK(res1)) {
12456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12457 }
12458 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12459 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12460 if (!SWIG_IsOK(ecode2)) {
12461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12462 }
12463 arg2 = static_cast< byte >(val2);
12464 if (arg1) (arg1)->red = arg2;
12465
12466 resultobj = SWIG_Py_Void();
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474 PyObject *resultobj = 0;
12475 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12476 byte result;
12477 void *argp1 = 0 ;
12478 int res1 = 0 ;
12479 PyObject *swig_obj[1] ;
12480
12481 if (!args) SWIG_fail;
12482 swig_obj[0] = args;
12483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12484 if (!SWIG_IsOK(res1)) {
12485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12486 }
12487 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12488 result = (byte) ((arg1)->red);
12489 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12497 PyObject *resultobj = 0;
12498 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12499 byte arg2 ;
12500 void *argp1 = 0 ;
12501 int res1 = 0 ;
12502 unsigned char val2 ;
12503 int ecode2 = 0 ;
12504 PyObject *swig_obj[2] ;
12505
12506 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12508 if (!SWIG_IsOK(res1)) {
12509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12510 }
12511 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12512 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12513 if (!SWIG_IsOK(ecode2)) {
12514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12515 }
12516 arg2 = static_cast< byte >(val2);
12517 if (arg1) (arg1)->green = arg2;
12518
12519 resultobj = SWIG_Py_Void();
12520 return resultobj;
12521 fail:
12522 return NULL;
12523 }
12524
12525
12526 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12527 PyObject *resultobj = 0;
12528 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12529 byte result;
12530 void *argp1 = 0 ;
12531 int res1 = 0 ;
12532 PyObject *swig_obj[1] ;
12533
12534 if (!args) SWIG_fail;
12535 swig_obj[0] = args;
12536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12537 if (!SWIG_IsOK(res1)) {
12538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12539 }
12540 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12541 result = (byte) ((arg1)->green);
12542 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12543 return resultobj;
12544 fail:
12545 return NULL;
12546 }
12547
12548
12549 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12550 PyObject *resultobj = 0;
12551 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12552 byte arg2 ;
12553 void *argp1 = 0 ;
12554 int res1 = 0 ;
12555 unsigned char val2 ;
12556 int ecode2 = 0 ;
12557 PyObject *swig_obj[2] ;
12558
12559 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12561 if (!SWIG_IsOK(res1)) {
12562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12563 }
12564 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12565 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12566 if (!SWIG_IsOK(ecode2)) {
12567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12568 }
12569 arg2 = static_cast< byte >(val2);
12570 if (arg1) (arg1)->blue = arg2;
12571
12572 resultobj = SWIG_Py_Void();
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12580 PyObject *resultobj = 0;
12581 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12582 byte result;
12583 void *argp1 = 0 ;
12584 int res1 = 0 ;
12585 PyObject *swig_obj[1] ;
12586
12587 if (!args) SWIG_fail;
12588 swig_obj[0] = args;
12589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12590 if (!SWIG_IsOK(res1)) {
12591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12592 }
12593 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12594 result = (byte) ((arg1)->blue);
12595 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12603 PyObject *obj;
12604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12605 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12606 return SWIG_Py_Void();
12607 }
12608
12609 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12610 return SWIG_Python_InitShadowInstance(args);
12611 }
12612
12613 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12614 PyObject *resultobj = 0;
12615 double arg1 = (double) 0.0 ;
12616 double arg2 = (double) 0.0 ;
12617 double arg3 = (double) 0.0 ;
12618 wxImage_HSVValue *result = 0 ;
12619 double val1 ;
12620 int ecode1 = 0 ;
12621 double val2 ;
12622 int ecode2 = 0 ;
12623 double val3 ;
12624 int ecode3 = 0 ;
12625 PyObject * obj0 = 0 ;
12626 PyObject * obj1 = 0 ;
12627 PyObject * obj2 = 0 ;
12628 char * kwnames[] = {
12629 (char *) "h",(char *) "s",(char *) "v", NULL
12630 };
12631
12632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12633 if (obj0) {
12634 ecode1 = SWIG_AsVal_double(obj0, &val1);
12635 if (!SWIG_IsOK(ecode1)) {
12636 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12637 }
12638 arg1 = static_cast< double >(val1);
12639 }
12640 if (obj1) {
12641 ecode2 = SWIG_AsVal_double(obj1, &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12644 }
12645 arg2 = static_cast< double >(val2);
12646 }
12647 if (obj2) {
12648 ecode3 = SWIG_AsVal_double(obj2, &val3);
12649 if (!SWIG_IsOK(ecode3)) {
12650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12651 }
12652 arg3 = static_cast< double >(val3);
12653 }
12654 {
12655 PyThreadState* __tstate = wxPyBeginAllowThreads();
12656 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12657 wxPyEndAllowThreads(__tstate);
12658 if (PyErr_Occurred()) SWIG_fail;
12659 }
12660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12661 return resultobj;
12662 fail:
12663 return NULL;
12664 }
12665
12666
12667 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12668 PyObject *resultobj = 0;
12669 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12670 double arg2 ;
12671 void *argp1 = 0 ;
12672 int res1 = 0 ;
12673 double val2 ;
12674 int ecode2 = 0 ;
12675 PyObject *swig_obj[2] ;
12676
12677 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12679 if (!SWIG_IsOK(res1)) {
12680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12681 }
12682 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12683 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12684 if (!SWIG_IsOK(ecode2)) {
12685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12686 }
12687 arg2 = static_cast< double >(val2);
12688 if (arg1) (arg1)->hue = arg2;
12689
12690 resultobj = SWIG_Py_Void();
12691 return resultobj;
12692 fail:
12693 return NULL;
12694 }
12695
12696
12697 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12698 PyObject *resultobj = 0;
12699 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12700 double result;
12701 void *argp1 = 0 ;
12702 int res1 = 0 ;
12703 PyObject *swig_obj[1] ;
12704
12705 if (!args) SWIG_fail;
12706 swig_obj[0] = args;
12707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12708 if (!SWIG_IsOK(res1)) {
12709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12710 }
12711 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12712 result = (double) ((arg1)->hue);
12713 resultobj = SWIG_From_double(static_cast< double >(result));
12714 return resultobj;
12715 fail:
12716 return NULL;
12717 }
12718
12719
12720 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12721 PyObject *resultobj = 0;
12722 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12723 double arg2 ;
12724 void *argp1 = 0 ;
12725 int res1 = 0 ;
12726 double val2 ;
12727 int ecode2 = 0 ;
12728 PyObject *swig_obj[2] ;
12729
12730 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12732 if (!SWIG_IsOK(res1)) {
12733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12734 }
12735 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12736 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12737 if (!SWIG_IsOK(ecode2)) {
12738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12739 }
12740 arg2 = static_cast< double >(val2);
12741 if (arg1) (arg1)->saturation = arg2;
12742
12743 resultobj = SWIG_Py_Void();
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12751 PyObject *resultobj = 0;
12752 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12753 double result;
12754 void *argp1 = 0 ;
12755 int res1 = 0 ;
12756 PyObject *swig_obj[1] ;
12757
12758 if (!args) SWIG_fail;
12759 swig_obj[0] = args;
12760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12761 if (!SWIG_IsOK(res1)) {
12762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12763 }
12764 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12765 result = (double) ((arg1)->saturation);
12766 resultobj = SWIG_From_double(static_cast< double >(result));
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12774 PyObject *resultobj = 0;
12775 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12776 double arg2 ;
12777 void *argp1 = 0 ;
12778 int res1 = 0 ;
12779 double val2 ;
12780 int ecode2 = 0 ;
12781 PyObject *swig_obj[2] ;
12782
12783 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12785 if (!SWIG_IsOK(res1)) {
12786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12787 }
12788 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12789 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12790 if (!SWIG_IsOK(ecode2)) {
12791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12792 }
12793 arg2 = static_cast< double >(val2);
12794 if (arg1) (arg1)->value = arg2;
12795
12796 resultobj = SWIG_Py_Void();
12797 return resultobj;
12798 fail:
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804 PyObject *resultobj = 0;
12805 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12806 double result;
12807 void *argp1 = 0 ;
12808 int res1 = 0 ;
12809 PyObject *swig_obj[1] ;
12810
12811 if (!args) SWIG_fail;
12812 swig_obj[0] = args;
12813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12814 if (!SWIG_IsOK(res1)) {
12815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12816 }
12817 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12818 result = (double) ((arg1)->value);
12819 resultobj = SWIG_From_double(static_cast< double >(result));
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 PyObject *obj;
12828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12829 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12830 return SWIG_Py_Void();
12831 }
12832
12833 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12834 return SWIG_Python_InitShadowInstance(args);
12835 }
12836
12837 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12838 PyObject *resultobj = 0;
12839 wxString *arg1 = 0 ;
12840 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12841 int arg3 = (int) -1 ;
12842 wxImage *result = 0 ;
12843 bool temp1 = false ;
12844 long val2 ;
12845 int ecode2 = 0 ;
12846 int val3 ;
12847 int ecode3 = 0 ;
12848 PyObject * obj0 = 0 ;
12849 PyObject * obj1 = 0 ;
12850 PyObject * obj2 = 0 ;
12851 char * kwnames[] = {
12852 (char *) "name",(char *) "type",(char *) "index", NULL
12853 };
12854
12855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12856 {
12857 arg1 = wxString_in_helper(obj0);
12858 if (arg1 == NULL) SWIG_fail;
12859 temp1 = true;
12860 }
12861 if (obj1) {
12862 ecode2 = SWIG_AsVal_long(obj1, &val2);
12863 if (!SWIG_IsOK(ecode2)) {
12864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12865 }
12866 arg2 = static_cast< long >(val2);
12867 }
12868 if (obj2) {
12869 ecode3 = SWIG_AsVal_int(obj2, &val3);
12870 if (!SWIG_IsOK(ecode3)) {
12871 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12872 }
12873 arg3 = static_cast< int >(val3);
12874 }
12875 {
12876 PyThreadState* __tstate = wxPyBeginAllowThreads();
12877 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12882 {
12883 if (temp1)
12884 delete arg1;
12885 }
12886 return resultobj;
12887 fail:
12888 {
12889 if (temp1)
12890 delete arg1;
12891 }
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 PyObject *resultobj = 0;
12898 wxImage *arg1 = (wxImage *) 0 ;
12899 void *argp1 = 0 ;
12900 int res1 = 0 ;
12901 PyObject *swig_obj[1] ;
12902
12903 if (!args) SWIG_fail;
12904 swig_obj[0] = args;
12905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12906 if (!SWIG_IsOK(res1)) {
12907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12908 }
12909 arg1 = reinterpret_cast< wxImage * >(argp1);
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 delete arg1;
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 resultobj = SWIG_Py_Void();
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12925 PyObject *resultobj = 0;
12926 wxString *arg1 = 0 ;
12927 wxString *arg2 = 0 ;
12928 int arg3 = (int) -1 ;
12929 wxImage *result = 0 ;
12930 bool temp1 = false ;
12931 bool temp2 = false ;
12932 int val3 ;
12933 int ecode3 = 0 ;
12934 PyObject * obj0 = 0 ;
12935 PyObject * obj1 = 0 ;
12936 PyObject * obj2 = 0 ;
12937 char * kwnames[] = {
12938 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12939 };
12940
12941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12942 {
12943 arg1 = wxString_in_helper(obj0);
12944 if (arg1 == NULL) SWIG_fail;
12945 temp1 = true;
12946 }
12947 {
12948 arg2 = wxString_in_helper(obj1);
12949 if (arg2 == NULL) SWIG_fail;
12950 temp2 = true;
12951 }
12952 if (obj2) {
12953 ecode3 = SWIG_AsVal_int(obj2, &val3);
12954 if (!SWIG_IsOK(ecode3)) {
12955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12956 }
12957 arg3 = static_cast< int >(val3);
12958 }
12959 {
12960 PyThreadState* __tstate = wxPyBeginAllowThreads();
12961 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12966 {
12967 if (temp1)
12968 delete arg1;
12969 }
12970 {
12971 if (temp2)
12972 delete arg2;
12973 }
12974 return resultobj;
12975 fail:
12976 {
12977 if (temp1)
12978 delete arg1;
12979 }
12980 {
12981 if (temp2)
12982 delete arg2;
12983 }
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12989 PyObject *resultobj = 0;
12990 wxInputStream *arg1 = 0 ;
12991 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12992 int arg3 = (int) -1 ;
12993 wxImage *result = 0 ;
12994 wxPyInputStream *temp1 ;
12995 bool created1 ;
12996 long val2 ;
12997 int ecode2 = 0 ;
12998 int val3 ;
12999 int ecode3 = 0 ;
13000 PyObject * obj0 = 0 ;
13001 PyObject * obj1 = 0 ;
13002 PyObject * obj2 = 0 ;
13003 char * kwnames[] = {
13004 (char *) "stream",(char *) "type",(char *) "index", NULL
13005 };
13006
13007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13008 {
13009 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13010 arg1 = temp1->m_wxis;
13011 created1 = false;
13012 } else {
13013 PyErr_Clear(); // clear the failure of the wxPyConvert above
13014 arg1 = wxPyCBInputStream_create(obj0, false);
13015 if (arg1 == NULL) {
13016 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13017 SWIG_fail;
13018 }
13019 created1 = true;
13020 }
13021 }
13022 if (obj1) {
13023 ecode2 = SWIG_AsVal_long(obj1, &val2);
13024 if (!SWIG_IsOK(ecode2)) {
13025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13026 }
13027 arg2 = static_cast< long >(val2);
13028 }
13029 if (obj2) {
13030 ecode3 = SWIG_AsVal_int(obj2, &val3);
13031 if (!SWIG_IsOK(ecode3)) {
13032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13033 }
13034 arg3 = static_cast< int >(val3);
13035 }
13036 {
13037 PyThreadState* __tstate = wxPyBeginAllowThreads();
13038 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13039 wxPyEndAllowThreads(__tstate);
13040 if (PyErr_Occurred()) SWIG_fail;
13041 }
13042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13043 {
13044 if (created1) delete arg1;
13045 }
13046 return resultobj;
13047 fail:
13048 {
13049 if (created1) delete arg1;
13050 }
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj = 0;
13057 wxInputStream *arg1 = 0 ;
13058 wxString *arg2 = 0 ;
13059 int arg3 = (int) -1 ;
13060 wxImage *result = 0 ;
13061 wxPyInputStream *temp1 ;
13062 bool created1 ;
13063 bool temp2 = false ;
13064 int val3 ;
13065 int ecode3 = 0 ;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 PyObject * obj2 = 0 ;
13069 char * kwnames[] = {
13070 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13071 };
13072
13073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13074 {
13075 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13076 arg1 = temp1->m_wxis;
13077 created1 = false;
13078 } else {
13079 PyErr_Clear(); // clear the failure of the wxPyConvert above
13080 arg1 = wxPyCBInputStream_create(obj0, false);
13081 if (arg1 == NULL) {
13082 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13083 SWIG_fail;
13084 }
13085 created1 = true;
13086 }
13087 }
13088 {
13089 arg2 = wxString_in_helper(obj1);
13090 if (arg2 == NULL) SWIG_fail;
13091 temp2 = true;
13092 }
13093 if (obj2) {
13094 ecode3 = SWIG_AsVal_int(obj2, &val3);
13095 if (!SWIG_IsOK(ecode3)) {
13096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13097 }
13098 arg3 = static_cast< int >(val3);
13099 }
13100 {
13101 PyThreadState* __tstate = wxPyBeginAllowThreads();
13102 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13107 {
13108 if (created1) delete arg1;
13109 }
13110 {
13111 if (temp2)
13112 delete arg2;
13113 }
13114 return resultobj;
13115 fail:
13116 {
13117 if (created1) delete arg1;
13118 }
13119 {
13120 if (temp2)
13121 delete arg2;
13122 }
13123 return NULL;
13124 }
13125
13126
13127 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13128 PyObject *resultobj = 0;
13129 int arg1 = (int) 0 ;
13130 int arg2 = (int) 0 ;
13131 bool arg3 = (bool) true ;
13132 wxImage *result = 0 ;
13133 int val1 ;
13134 int ecode1 = 0 ;
13135 int val2 ;
13136 int ecode2 = 0 ;
13137 bool val3 ;
13138 int ecode3 = 0 ;
13139 PyObject * obj0 = 0 ;
13140 PyObject * obj1 = 0 ;
13141 PyObject * obj2 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "width",(char *) "height",(char *) "clear", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13147 if (obj0) {
13148 ecode1 = SWIG_AsVal_int(obj0, &val1);
13149 if (!SWIG_IsOK(ecode1)) {
13150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13151 }
13152 arg1 = static_cast< int >(val1);
13153 }
13154 if (obj1) {
13155 ecode2 = SWIG_AsVal_int(obj1, &val2);
13156 if (!SWIG_IsOK(ecode2)) {
13157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13158 }
13159 arg2 = static_cast< int >(val2);
13160 }
13161 if (obj2) {
13162 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13163 if (!SWIG_IsOK(ecode3)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13165 }
13166 arg3 = static_cast< bool >(val3);
13167 }
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13175 return resultobj;
13176 fail:
13177 return NULL;
13178 }
13179
13180
13181 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13182 PyObject *resultobj = 0;
13183 wxBitmap *arg1 = 0 ;
13184 wxImage *result = 0 ;
13185 void *argp1 = 0 ;
13186 int res1 = 0 ;
13187 PyObject * obj0 = 0 ;
13188 char * kwnames[] = {
13189 (char *) "bitmap", NULL
13190 };
13191
13192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13193 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13194 if (!SWIG_IsOK(res1)) {
13195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13196 }
13197 if (!argp1) {
13198 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13199 }
13200 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13201 {
13202 if (!wxPyCheckForApp()) SWIG_fail;
13203 PyThreadState* __tstate = wxPyBeginAllowThreads();
13204 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13205 wxPyEndAllowThreads(__tstate);
13206 if (PyErr_Occurred()) SWIG_fail;
13207 }
13208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13209 return resultobj;
13210 fail:
13211 return NULL;
13212 }
13213
13214
13215 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13216 PyObject *resultobj = 0;
13217 int arg1 ;
13218 int arg2 ;
13219 buffer arg3 ;
13220 int arg4 ;
13221 wxImage *result = 0 ;
13222 int val1 ;
13223 int ecode1 = 0 ;
13224 int val2 ;
13225 int ecode2 = 0 ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 PyObject * obj2 = 0 ;
13229 char * kwnames[] = {
13230 (char *) "width",(char *) "height",(char *) "data", NULL
13231 };
13232
13233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13234 ecode1 = SWIG_AsVal_int(obj0, &val1);
13235 if (!SWIG_IsOK(ecode1)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13237 }
13238 arg1 = static_cast< int >(val1);
13239 ecode2 = SWIG_AsVal_int(obj1, &val2);
13240 if (!SWIG_IsOK(ecode2)) {
13241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13242 }
13243 arg2 = static_cast< int >(val2);
13244 {
13245 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13246 }
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13261 PyObject *resultobj = 0;
13262 int arg1 ;
13263 int arg2 ;
13264 buffer arg3 ;
13265 int arg4 ;
13266 buffer arg5 ;
13267 int arg6 ;
13268 wxImage *result = 0 ;
13269 int val1 ;
13270 int ecode1 = 0 ;
13271 int val2 ;
13272 int ecode2 = 0 ;
13273 PyObject * obj0 = 0 ;
13274 PyObject * obj1 = 0 ;
13275 PyObject * obj2 = 0 ;
13276 PyObject * obj3 = 0 ;
13277 char * kwnames[] = {
13278 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13279 };
13280
13281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13282 ecode1 = SWIG_AsVal_int(obj0, &val1);
13283 if (!SWIG_IsOK(ecode1)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13285 }
13286 arg1 = static_cast< int >(val1);
13287 ecode2 = SWIG_AsVal_int(obj1, &val2);
13288 if (!SWIG_IsOK(ecode2)) {
13289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13290 }
13291 arg2 = static_cast< int >(val2);
13292 {
13293 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13294 }
13295 {
13296 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13297 }
13298 {
13299 PyThreadState* __tstate = wxPyBeginAllowThreads();
13300 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13301 wxPyEndAllowThreads(__tstate);
13302 if (PyErr_Occurred()) SWIG_fail;
13303 }
13304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13312 PyObject *resultobj = 0;
13313 wxImage *arg1 = (wxImage *) 0 ;
13314 int arg2 ;
13315 int arg3 ;
13316 bool arg4 = (bool) true ;
13317 void *argp1 = 0 ;
13318 int res1 = 0 ;
13319 int val2 ;
13320 int ecode2 = 0 ;
13321 int val3 ;
13322 int ecode3 = 0 ;
13323 bool val4 ;
13324 int ecode4 = 0 ;
13325 PyObject * obj0 = 0 ;
13326 PyObject * obj1 = 0 ;
13327 PyObject * obj2 = 0 ;
13328 PyObject * obj3 = 0 ;
13329 char * kwnames[] = {
13330 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13331 };
13332
13333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13335 if (!SWIG_IsOK(res1)) {
13336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13337 }
13338 arg1 = reinterpret_cast< wxImage * >(argp1);
13339 ecode2 = SWIG_AsVal_int(obj1, &val2);
13340 if (!SWIG_IsOK(ecode2)) {
13341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13342 }
13343 arg2 = static_cast< int >(val2);
13344 ecode3 = SWIG_AsVal_int(obj2, &val3);
13345 if (!SWIG_IsOK(ecode3)) {
13346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13347 }
13348 arg3 = static_cast< int >(val3);
13349 if (obj3) {
13350 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13351 if (!SWIG_IsOK(ecode4)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13353 }
13354 arg4 = static_cast< bool >(val4);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 (arg1)->Create(arg2,arg3,arg4);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_Py_Void();
13363 return resultobj;
13364 fail:
13365 return NULL;
13366 }
13367
13368
13369 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13370 PyObject *resultobj = 0;
13371 wxImage *arg1 = (wxImage *) 0 ;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 PyObject *swig_obj[1] ;
13375
13376 if (!args) SWIG_fail;
13377 swig_obj[0] = args;
13378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13379 if (!SWIG_IsOK(res1)) {
13380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13381 }
13382 arg1 = reinterpret_cast< wxImage * >(argp1);
13383 {
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 (arg1)->Destroy();
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 resultobj = SWIG_Py_Void();
13390 return resultobj;
13391 fail:
13392 return NULL;
13393 }
13394
13395
13396 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13397 PyObject *resultobj = 0;
13398 wxImage *arg1 = (wxImage *) 0 ;
13399 int arg2 ;
13400 int arg3 ;
13401 SwigValueWrapper<wxImage > result;
13402 void *argp1 = 0 ;
13403 int res1 = 0 ;
13404 int val2 ;
13405 int ecode2 = 0 ;
13406 int val3 ;
13407 int ecode3 = 0 ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 PyObject * obj2 = 0 ;
13411 char * kwnames[] = {
13412 (char *) "self",(char *) "width",(char *) "height", NULL
13413 };
13414
13415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13419 }
13420 arg1 = reinterpret_cast< wxImage * >(argp1);
13421 ecode2 = SWIG_AsVal_int(obj1, &val2);
13422 if (!SWIG_IsOK(ecode2)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13424 }
13425 arg2 = static_cast< int >(val2);
13426 ecode3 = SWIG_AsVal_int(obj2, &val3);
13427 if (!SWIG_IsOK(ecode3)) {
13428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13429 }
13430 arg3 = static_cast< int >(val3);
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (arg1)->Scale(arg2,arg3);
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj = 0;
13446 wxImage *arg1 = (wxImage *) 0 ;
13447 int arg2 ;
13448 int arg3 ;
13449 SwigValueWrapper<wxImage > result;
13450 void *argp1 = 0 ;
13451 int res1 = 0 ;
13452 int val2 ;
13453 int ecode2 = 0 ;
13454 int val3 ;
13455 int ecode3 = 0 ;
13456 PyObject * obj0 = 0 ;
13457 PyObject * obj1 = 0 ;
13458 PyObject * obj2 = 0 ;
13459 char * kwnames[] = {
13460 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13461 };
13462
13463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13465 if (!SWIG_IsOK(res1)) {
13466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13467 }
13468 arg1 = reinterpret_cast< wxImage * >(argp1);
13469 ecode2 = SWIG_AsVal_int(obj1, &val2);
13470 if (!SWIG_IsOK(ecode2)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13472 }
13473 arg2 = static_cast< int >(val2);
13474 ecode3 = SWIG_AsVal_int(obj2, &val3);
13475 if (!SWIG_IsOK(ecode3)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13477 }
13478 arg3 = static_cast< int >(val3);
13479 {
13480 PyThreadState* __tstate = wxPyBeginAllowThreads();
13481 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13482 wxPyEndAllowThreads(__tstate);
13483 if (PyErr_Occurred()) SWIG_fail;
13484 }
13485 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13486 return resultobj;
13487 fail:
13488 return NULL;
13489 }
13490
13491
13492 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj = 0;
13494 wxImage *arg1 = (wxImage *) 0 ;
13495 int arg2 ;
13496 int arg3 ;
13497 wxImage *result = 0 ;
13498 void *argp1 = 0 ;
13499 int res1 = 0 ;
13500 int val2 ;
13501 int ecode2 = 0 ;
13502 int val3 ;
13503 int ecode3 = 0 ;
13504 PyObject * obj0 = 0 ;
13505 PyObject * obj1 = 0 ;
13506 PyObject * obj2 = 0 ;
13507 char * kwnames[] = {
13508 (char *) "self",(char *) "width",(char *) "height", NULL
13509 };
13510
13511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13513 if (!SWIG_IsOK(res1)) {
13514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13515 }
13516 arg1 = reinterpret_cast< wxImage * >(argp1);
13517 ecode2 = SWIG_AsVal_int(obj1, &val2);
13518 if (!SWIG_IsOK(ecode2)) {
13519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13520 }
13521 arg2 = static_cast< int >(val2);
13522 ecode3 = SWIG_AsVal_int(obj2, &val3);
13523 if (!SWIG_IsOK(ecode3)) {
13524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13525 }
13526 arg3 = static_cast< int >(val3);
13527 {
13528 PyThreadState* __tstate = wxPyBeginAllowThreads();
13529 {
13530 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13531 result = (wxImage *) &_result_ref;
13532 }
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13537 return resultobj;
13538 fail:
13539 return NULL;
13540 }
13541
13542
13543 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13544 PyObject *resultobj = 0;
13545 wxImage *arg1 = (wxImage *) 0 ;
13546 wxSize *arg2 = 0 ;
13547 wxPoint *arg3 = 0 ;
13548 int arg4 = (int) -1 ;
13549 int arg5 = (int) -1 ;
13550 int arg6 = (int) -1 ;
13551 wxImage *result = 0 ;
13552 void *argp1 = 0 ;
13553 int res1 = 0 ;
13554 wxSize temp2 ;
13555 wxPoint temp3 ;
13556 int val4 ;
13557 int ecode4 = 0 ;
13558 int val5 ;
13559 int ecode5 = 0 ;
13560 int val6 ;
13561 int ecode6 = 0 ;
13562 PyObject * obj0 = 0 ;
13563 PyObject * obj1 = 0 ;
13564 PyObject * obj2 = 0 ;
13565 PyObject * obj3 = 0 ;
13566 PyObject * obj4 = 0 ;
13567 PyObject * obj5 = 0 ;
13568 char * kwnames[] = {
13569 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13570 };
13571
13572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13574 if (!SWIG_IsOK(res1)) {
13575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13576 }
13577 arg1 = reinterpret_cast< wxImage * >(argp1);
13578 {
13579 arg2 = &temp2;
13580 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13581 }
13582 {
13583 arg3 = &temp3;
13584 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13585 }
13586 if (obj3) {
13587 ecode4 = SWIG_AsVal_int(obj3, &val4);
13588 if (!SWIG_IsOK(ecode4)) {
13589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13590 }
13591 arg4 = static_cast< int >(val4);
13592 }
13593 if (obj4) {
13594 ecode5 = SWIG_AsVal_int(obj4, &val5);
13595 if (!SWIG_IsOK(ecode5)) {
13596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13597 }
13598 arg5 = static_cast< int >(val5);
13599 }
13600 if (obj5) {
13601 ecode6 = SWIG_AsVal_int(obj5, &val6);
13602 if (!SWIG_IsOK(ecode6)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13604 }
13605 arg6 = static_cast< int >(val6);
13606 }
13607 {
13608 PyThreadState* __tstate = wxPyBeginAllowThreads();
13609 {
13610 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13611 result = (wxImage *) &_result_ref;
13612 }
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13624 PyObject *resultobj = 0;
13625 wxImage *arg1 = (wxImage *) 0 ;
13626 int arg2 ;
13627 int arg3 ;
13628 byte arg4 ;
13629 byte arg5 ;
13630 byte arg6 ;
13631 void *argp1 = 0 ;
13632 int res1 = 0 ;
13633 int val2 ;
13634 int ecode2 = 0 ;
13635 int val3 ;
13636 int ecode3 = 0 ;
13637 unsigned char val4 ;
13638 int ecode4 = 0 ;
13639 unsigned char val5 ;
13640 int ecode5 = 0 ;
13641 unsigned char 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 *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13651 };
13652
13653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",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_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13657 }
13658 arg1 = reinterpret_cast< wxImage * >(argp1);
13659 ecode2 = SWIG_AsVal_int(obj1, &val2);
13660 if (!SWIG_IsOK(ecode2)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13662 }
13663 arg2 = static_cast< int >(val2);
13664 ecode3 = SWIG_AsVal_int(obj2, &val3);
13665 if (!SWIG_IsOK(ecode3)) {
13666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13667 }
13668 arg3 = static_cast< int >(val3);
13669 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13670 if (!SWIG_IsOK(ecode4)) {
13671 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13672 }
13673 arg4 = static_cast< byte >(val4);
13674 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13675 if (!SWIG_IsOK(ecode5)) {
13676 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13677 }
13678 arg5 = static_cast< byte >(val5);
13679 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13680 if (!SWIG_IsOK(ecode6)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13682 }
13683 arg6 = static_cast< byte >(val6);
13684 {
13685 PyThreadState* __tstate = wxPyBeginAllowThreads();
13686 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13687 wxPyEndAllowThreads(__tstate);
13688 if (PyErr_Occurred()) SWIG_fail;
13689 }
13690 resultobj = SWIG_Py_Void();
13691 return resultobj;
13692 fail:
13693 return NULL;
13694 }
13695
13696
13697 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13698 PyObject *resultobj = 0;
13699 wxImage *arg1 = (wxImage *) 0 ;
13700 wxRect *arg2 = 0 ;
13701 byte arg3 ;
13702 byte arg4 ;
13703 byte arg5 ;
13704 void *argp1 = 0 ;
13705 int res1 = 0 ;
13706 wxRect temp2 ;
13707 unsigned char val3 ;
13708 int ecode3 = 0 ;
13709 unsigned char val4 ;
13710 int ecode4 = 0 ;
13711 unsigned char val5 ;
13712 int ecode5 = 0 ;
13713 PyObject * obj0 = 0 ;
13714 PyObject * obj1 = 0 ;
13715 PyObject * obj2 = 0 ;
13716 PyObject * obj3 = 0 ;
13717 PyObject * obj4 = 0 ;
13718 char * kwnames[] = {
13719 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13720 };
13721
13722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13724 if (!SWIG_IsOK(res1)) {
13725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13726 }
13727 arg1 = reinterpret_cast< wxImage * >(argp1);
13728 {
13729 arg2 = &temp2;
13730 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13731 }
13732 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13733 if (!SWIG_IsOK(ecode3)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13735 }
13736 arg3 = static_cast< byte >(val3);
13737 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13738 if (!SWIG_IsOK(ecode4)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13740 }
13741 arg4 = static_cast< byte >(val4);
13742 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13743 if (!SWIG_IsOK(ecode5)) {
13744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13745 }
13746 arg5 = static_cast< byte >(val5);
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 resultobj = SWIG_Py_Void();
13754 return resultobj;
13755 fail:
13756 return NULL;
13757 }
13758
13759
13760 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13761 PyObject *resultobj = 0;
13762 wxImage *arg1 = (wxImage *) 0 ;
13763 int arg2 ;
13764 int arg3 ;
13765 byte result;
13766 void *argp1 = 0 ;
13767 int res1 = 0 ;
13768 int val2 ;
13769 int ecode2 = 0 ;
13770 int val3 ;
13771 int ecode3 = 0 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 char * kwnames[] = {
13776 (char *) "self",(char *) "x",(char *) "y", NULL
13777 };
13778
13779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13781 if (!SWIG_IsOK(res1)) {
13782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13783 }
13784 arg1 = reinterpret_cast< wxImage * >(argp1);
13785 ecode2 = SWIG_AsVal_int(obj1, &val2);
13786 if (!SWIG_IsOK(ecode2)) {
13787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13788 }
13789 arg2 = static_cast< int >(val2);
13790 ecode3 = SWIG_AsVal_int(obj2, &val3);
13791 if (!SWIG_IsOK(ecode3)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13793 }
13794 arg3 = static_cast< int >(val3);
13795 {
13796 PyThreadState* __tstate = wxPyBeginAllowThreads();
13797 result = (byte)(arg1)->GetRed(arg2,arg3);
13798 wxPyEndAllowThreads(__tstate);
13799 if (PyErr_Occurred()) SWIG_fail;
13800 }
13801 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj = 0;
13810 wxImage *arg1 = (wxImage *) 0 ;
13811 int arg2 ;
13812 int arg3 ;
13813 byte result;
13814 void *argp1 = 0 ;
13815 int res1 = 0 ;
13816 int val2 ;
13817 int ecode2 = 0 ;
13818 int val3 ;
13819 int ecode3 = 0 ;
13820 PyObject * obj0 = 0 ;
13821 PyObject * obj1 = 0 ;
13822 PyObject * obj2 = 0 ;
13823 char * kwnames[] = {
13824 (char *) "self",(char *) "x",(char *) "y", NULL
13825 };
13826
13827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13829 if (!SWIG_IsOK(res1)) {
13830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13831 }
13832 arg1 = reinterpret_cast< wxImage * >(argp1);
13833 ecode2 = SWIG_AsVal_int(obj1, &val2);
13834 if (!SWIG_IsOK(ecode2)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13836 }
13837 arg2 = static_cast< int >(val2);
13838 ecode3 = SWIG_AsVal_int(obj2, &val3);
13839 if (!SWIG_IsOK(ecode3)) {
13840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13841 }
13842 arg3 = static_cast< int >(val3);
13843 {
13844 PyThreadState* __tstate = wxPyBeginAllowThreads();
13845 result = (byte)(arg1)->GetGreen(arg2,arg3);
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj = 0;
13858 wxImage *arg1 = (wxImage *) 0 ;
13859 int arg2 ;
13860 int arg3 ;
13861 byte result;
13862 void *argp1 = 0 ;
13863 int res1 = 0 ;
13864 int val2 ;
13865 int ecode2 = 0 ;
13866 int val3 ;
13867 int ecode3 = 0 ;
13868 PyObject * obj0 = 0 ;
13869 PyObject * obj1 = 0 ;
13870 PyObject * obj2 = 0 ;
13871 char * kwnames[] = {
13872 (char *) "self",(char *) "x",(char *) "y", NULL
13873 };
13874
13875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13877 if (!SWIG_IsOK(res1)) {
13878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13879 }
13880 arg1 = reinterpret_cast< wxImage * >(argp1);
13881 ecode2 = SWIG_AsVal_int(obj1, &val2);
13882 if (!SWIG_IsOK(ecode2)) {
13883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13884 }
13885 arg2 = static_cast< int >(val2);
13886 ecode3 = SWIG_AsVal_int(obj2, &val3);
13887 if (!SWIG_IsOK(ecode3)) {
13888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13889 }
13890 arg3 = static_cast< int >(val3);
13891 {
13892 PyThreadState* __tstate = wxPyBeginAllowThreads();
13893 result = (byte)(arg1)->GetBlue(arg2,arg3);
13894 wxPyEndAllowThreads(__tstate);
13895 if (PyErr_Occurred()) SWIG_fail;
13896 }
13897 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13898 return resultobj;
13899 fail:
13900 return NULL;
13901 }
13902
13903
13904 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13905 PyObject *resultobj = 0;
13906 wxImage *arg1 = (wxImage *) 0 ;
13907 int arg2 ;
13908 int arg3 ;
13909 byte arg4 ;
13910 void *argp1 = 0 ;
13911 int res1 = 0 ;
13912 int val2 ;
13913 int ecode2 = 0 ;
13914 int val3 ;
13915 int ecode3 = 0 ;
13916 unsigned char val4 ;
13917 int ecode4 = 0 ;
13918 PyObject * obj0 = 0 ;
13919 PyObject * obj1 = 0 ;
13920 PyObject * obj2 = 0 ;
13921 PyObject * obj3 = 0 ;
13922 char * kwnames[] = {
13923 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13924 };
13925
13926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13928 if (!SWIG_IsOK(res1)) {
13929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13930 }
13931 arg1 = reinterpret_cast< wxImage * >(argp1);
13932 ecode2 = SWIG_AsVal_int(obj1, &val2);
13933 if (!SWIG_IsOK(ecode2)) {
13934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13935 }
13936 arg2 = static_cast< int >(val2);
13937 ecode3 = SWIG_AsVal_int(obj2, &val3);
13938 if (!SWIG_IsOK(ecode3)) {
13939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13940 }
13941 arg3 = static_cast< int >(val3);
13942 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13943 if (!SWIG_IsOK(ecode4)) {
13944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13945 }
13946 arg4 = static_cast< byte >(val4);
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 (arg1)->SetAlpha(arg2,arg3,arg4);
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 resultobj = SWIG_Py_Void();
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj = 0;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 int arg2 ;
13964 int arg3 ;
13965 byte result;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 int val2 ;
13969 int ecode2 = 0 ;
13970 int val3 ;
13971 int ecode3 = 0 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 char * kwnames[] = {
13976 (char *) "self",(char *) "x",(char *) "y", NULL
13977 };
13978
13979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13981 if (!SWIG_IsOK(res1)) {
13982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13983 }
13984 arg1 = reinterpret_cast< wxImage * >(argp1);
13985 ecode2 = SWIG_AsVal_int(obj1, &val2);
13986 if (!SWIG_IsOK(ecode2)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13988 }
13989 arg2 = static_cast< int >(val2);
13990 ecode3 = SWIG_AsVal_int(obj2, &val3);
13991 if (!SWIG_IsOK(ecode3)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13993 }
13994 arg3 = static_cast< int >(val3);
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14009 PyObject *resultobj = 0;
14010 wxImage *arg1 = (wxImage *) 0 ;
14011 bool result;
14012 void *argp1 = 0 ;
14013 int res1 = 0 ;
14014 PyObject *swig_obj[1] ;
14015
14016 if (!args) SWIG_fail;
14017 swig_obj[0] = args;
14018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14019 if (!SWIG_IsOK(res1)) {
14020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14021 }
14022 arg1 = reinterpret_cast< wxImage * >(argp1);
14023 {
14024 PyThreadState* __tstate = wxPyBeginAllowThreads();
14025 result = (bool)(arg1)->HasAlpha();
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 {
14030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14031 }
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14039 PyObject *resultobj = 0;
14040 wxImage *arg1 = (wxImage *) 0 ;
14041 void *argp1 = 0 ;
14042 int res1 = 0 ;
14043 PyObject *swig_obj[1] ;
14044
14045 if (!args) SWIG_fail;
14046 swig_obj[0] = args;
14047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14048 if (!SWIG_IsOK(res1)) {
14049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14050 }
14051 arg1 = reinterpret_cast< wxImage * >(argp1);
14052 {
14053 PyThreadState* __tstate = wxPyBeginAllowThreads();
14054 (arg1)->InitAlpha();
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 resultobj = SWIG_Py_Void();
14059 return resultobj;
14060 fail:
14061 return NULL;
14062 }
14063
14064
14065 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14066 PyObject *resultobj = 0;
14067 wxImage *arg1 = (wxImage *) 0 ;
14068 int arg2 ;
14069 int arg3 ;
14070 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14071 bool result;
14072 void *argp1 = 0 ;
14073 int res1 = 0 ;
14074 int val2 ;
14075 int ecode2 = 0 ;
14076 int val3 ;
14077 int ecode3 = 0 ;
14078 unsigned char val4 ;
14079 int ecode4 = 0 ;
14080 PyObject * obj0 = 0 ;
14081 PyObject * obj1 = 0 ;
14082 PyObject * obj2 = 0 ;
14083 PyObject * obj3 = 0 ;
14084 char * kwnames[] = {
14085 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14086 };
14087
14088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14090 if (!SWIG_IsOK(res1)) {
14091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14092 }
14093 arg1 = reinterpret_cast< wxImage * >(argp1);
14094 ecode2 = SWIG_AsVal_int(obj1, &val2);
14095 if (!SWIG_IsOK(ecode2)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14097 }
14098 arg2 = static_cast< int >(val2);
14099 ecode3 = SWIG_AsVal_int(obj2, &val3);
14100 if (!SWIG_IsOK(ecode3)) {
14101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14102 }
14103 arg3 = static_cast< int >(val3);
14104 if (obj3) {
14105 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14106 if (!SWIG_IsOK(ecode4)) {
14107 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14108 }
14109 arg4 = static_cast< byte >(val4);
14110 }
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 {
14118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14119 }
14120 return resultobj;
14121 fail:
14122 return NULL;
14123 }
14124
14125
14126 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14127 PyObject *resultobj = 0;
14128 wxImage *arg1 = (wxImage *) 0 ;
14129 byte *arg2 = (byte *) 0 ;
14130 byte *arg3 = (byte *) 0 ;
14131 byte *arg4 = (byte *) 0 ;
14132 byte arg5 = (byte) 0 ;
14133 byte arg6 = (byte) 0 ;
14134 byte arg7 = (byte) 0 ;
14135 bool result;
14136 void *argp1 = 0 ;
14137 int res1 = 0 ;
14138 byte temp2 ;
14139 int res2 = SWIG_TMPOBJ ;
14140 byte temp3 ;
14141 int res3 = SWIG_TMPOBJ ;
14142 byte temp4 ;
14143 int res4 = SWIG_TMPOBJ ;
14144 unsigned char val5 ;
14145 int ecode5 = 0 ;
14146 unsigned char val6 ;
14147 int ecode6 = 0 ;
14148 unsigned char val7 ;
14149 int ecode7 = 0 ;
14150 PyObject * obj0 = 0 ;
14151 PyObject * obj1 = 0 ;
14152 PyObject * obj2 = 0 ;
14153 PyObject * obj3 = 0 ;
14154 char * kwnames[] = {
14155 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14156 };
14157
14158 arg2 = &temp2;
14159 arg3 = &temp3;
14160 arg4 = &temp4;
14161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14163 if (!SWIG_IsOK(res1)) {
14164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14165 }
14166 arg1 = reinterpret_cast< wxImage * >(argp1);
14167 if (obj1) {
14168 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14169 if (!SWIG_IsOK(ecode5)) {
14170 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14171 }
14172 arg5 = static_cast< byte >(val5);
14173 }
14174 if (obj2) {
14175 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14176 if (!SWIG_IsOK(ecode6)) {
14177 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14178 }
14179 arg6 = static_cast< byte >(val6);
14180 }
14181 if (obj3) {
14182 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14183 if (!SWIG_IsOK(ecode7)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14185 }
14186 arg7 = static_cast< byte >(val7);
14187 }
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 {
14195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14196 }
14197 if (SWIG_IsTmpObj(res2)) {
14198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14199 } else {
14200 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14202 }
14203 if (SWIG_IsTmpObj(res3)) {
14204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14205 } else {
14206 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14208 }
14209 if (SWIG_IsTmpObj(res4)) {
14210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14211 } else {
14212 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14214 }
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxImage *arg1 = (wxImage *) 0 ;
14224 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14225 bool result;
14226 void *argp1 = 0 ;
14227 int res1 = 0 ;
14228 unsigned char val2 ;
14229 int ecode2 = 0 ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 char * kwnames[] = {
14233 (char *) "self",(char *) "threshold", NULL
14234 };
14235
14236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14238 if (!SWIG_IsOK(res1)) {
14239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14240 }
14241 arg1 = reinterpret_cast< wxImage * >(argp1);
14242 if (obj1) {
14243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14244 if (!SWIG_IsOK(ecode2)) {
14245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14246 }
14247 arg2 = static_cast< byte >(val2);
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14252 wxPyEndAllowThreads(__tstate);
14253 if (PyErr_Occurred()) SWIG_fail;
14254 }
14255 {
14256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14257 }
14258 return resultobj;
14259 fail:
14260 return NULL;
14261 }
14262
14263
14264 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14265 PyObject *resultobj = 0;
14266 wxImage *arg1 = (wxImage *) 0 ;
14267 byte arg2 ;
14268 byte arg3 ;
14269 byte arg4 ;
14270 bool result;
14271 void *argp1 = 0 ;
14272 int res1 = 0 ;
14273 unsigned char val2 ;
14274 int ecode2 = 0 ;
14275 unsigned char val3 ;
14276 int ecode3 = 0 ;
14277 unsigned char val4 ;
14278 int ecode4 = 0 ;
14279 PyObject * obj0 = 0 ;
14280 PyObject * obj1 = 0 ;
14281 PyObject * obj2 = 0 ;
14282 PyObject * obj3 = 0 ;
14283 char * kwnames[] = {
14284 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14285 };
14286
14287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14289 if (!SWIG_IsOK(res1)) {
14290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14291 }
14292 arg1 = reinterpret_cast< wxImage * >(argp1);
14293 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14294 if (!SWIG_IsOK(ecode2)) {
14295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14296 }
14297 arg2 = static_cast< byte >(val2);
14298 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14299 if (!SWIG_IsOK(ecode3)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14301 }
14302 arg3 = static_cast< byte >(val3);
14303 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14304 if (!SWIG_IsOK(ecode4)) {
14305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14306 }
14307 arg4 = static_cast< byte >(val4);
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 {
14315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14316 }
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14324 PyObject *resultobj = 0;
14325 wxImage *arg1 = (wxImage *) 0 ;
14326 wxImage *arg2 = 0 ;
14327 byte arg3 ;
14328 byte arg4 ;
14329 byte arg5 ;
14330 bool result;
14331 void *argp1 = 0 ;
14332 int res1 = 0 ;
14333 void *argp2 = 0 ;
14334 int res2 = 0 ;
14335 unsigned char val3 ;
14336 int ecode3 = 0 ;
14337 unsigned char val4 ;
14338 int ecode4 = 0 ;
14339 unsigned char val5 ;
14340 int ecode5 = 0 ;
14341 PyObject * obj0 = 0 ;
14342 PyObject * obj1 = 0 ;
14343 PyObject * obj2 = 0 ;
14344 PyObject * obj3 = 0 ;
14345 PyObject * obj4 = 0 ;
14346 char * kwnames[] = {
14347 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14348 };
14349
14350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14352 if (!SWIG_IsOK(res1)) {
14353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14354 }
14355 arg1 = reinterpret_cast< wxImage * >(argp1);
14356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14357 if (!SWIG_IsOK(res2)) {
14358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14359 }
14360 if (!argp2) {
14361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14362 }
14363 arg2 = reinterpret_cast< wxImage * >(argp2);
14364 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14365 if (!SWIG_IsOK(ecode3)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14367 }
14368 arg3 = static_cast< byte >(val3);
14369 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14370 if (!SWIG_IsOK(ecode4)) {
14371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14372 }
14373 arg4 = static_cast< byte >(val4);
14374 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14375 if (!SWIG_IsOK(ecode5)) {
14376 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14377 }
14378 arg5 = static_cast< byte >(val5);
14379 {
14380 PyThreadState* __tstate = wxPyBeginAllowThreads();
14381 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 {
14386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14387 }
14388 return resultobj;
14389 fail:
14390 return NULL;
14391 }
14392
14393
14394 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14395 PyObject *resultobj = 0;
14396 wxString *arg1 = 0 ;
14397 bool result;
14398 bool temp1 = false ;
14399 PyObject * obj0 = 0 ;
14400 char * kwnames[] = {
14401 (char *) "filename", NULL
14402 };
14403
14404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14405 {
14406 arg1 = wxString_in_helper(obj0);
14407 if (arg1 == NULL) SWIG_fail;
14408 temp1 = true;
14409 }
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 {
14417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14418 }
14419 {
14420 if (temp1)
14421 delete arg1;
14422 }
14423 return resultobj;
14424 fail:
14425 {
14426 if (temp1)
14427 delete arg1;
14428 }
14429 return NULL;
14430 }
14431
14432
14433 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj = 0;
14435 wxString *arg1 = 0 ;
14436 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14437 int result;
14438 bool temp1 = false ;
14439 long val2 ;
14440 int ecode2 = 0 ;
14441 PyObject * obj0 = 0 ;
14442 PyObject * obj1 = 0 ;
14443 char * kwnames[] = {
14444 (char *) "filename",(char *) "type", NULL
14445 };
14446
14447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14448 {
14449 arg1 = wxString_in_helper(obj0);
14450 if (arg1 == NULL) SWIG_fail;
14451 temp1 = true;
14452 }
14453 if (obj1) {
14454 ecode2 = SWIG_AsVal_long(obj1, &val2);
14455 if (!SWIG_IsOK(ecode2)) {
14456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14457 }
14458 arg2 = static_cast< long >(val2);
14459 }
14460 {
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14463 wxPyEndAllowThreads(__tstate);
14464 if (PyErr_Occurred()) SWIG_fail;
14465 }
14466 resultobj = SWIG_From_int(static_cast< int >(result));
14467 {
14468 if (temp1)
14469 delete arg1;
14470 }
14471 return resultobj;
14472 fail:
14473 {
14474 if (temp1)
14475 delete arg1;
14476 }
14477 return NULL;
14478 }
14479
14480
14481 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14482 PyObject *resultobj = 0;
14483 wxImage *arg1 = (wxImage *) 0 ;
14484 wxString *arg2 = 0 ;
14485 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14486 int arg4 = (int) -1 ;
14487 bool result;
14488 void *argp1 = 0 ;
14489 int res1 = 0 ;
14490 bool temp2 = false ;
14491 long val3 ;
14492 int ecode3 = 0 ;
14493 int val4 ;
14494 int ecode4 = 0 ;
14495 PyObject * obj0 = 0 ;
14496 PyObject * obj1 = 0 ;
14497 PyObject * obj2 = 0 ;
14498 PyObject * obj3 = 0 ;
14499 char * kwnames[] = {
14500 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14501 };
14502
14503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14505 if (!SWIG_IsOK(res1)) {
14506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14507 }
14508 arg1 = reinterpret_cast< wxImage * >(argp1);
14509 {
14510 arg2 = wxString_in_helper(obj1);
14511 if (arg2 == NULL) SWIG_fail;
14512 temp2 = true;
14513 }
14514 if (obj2) {
14515 ecode3 = SWIG_AsVal_long(obj2, &val3);
14516 if (!SWIG_IsOK(ecode3)) {
14517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14518 }
14519 arg3 = static_cast< long >(val3);
14520 }
14521 if (obj3) {
14522 ecode4 = SWIG_AsVal_int(obj3, &val4);
14523 if (!SWIG_IsOK(ecode4)) {
14524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14525 }
14526 arg4 = static_cast< int >(val4);
14527 }
14528 {
14529 PyThreadState* __tstate = wxPyBeginAllowThreads();
14530 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 {
14535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14536 }
14537 {
14538 if (temp2)
14539 delete arg2;
14540 }
14541 return resultobj;
14542 fail:
14543 {
14544 if (temp2)
14545 delete arg2;
14546 }
14547 return NULL;
14548 }
14549
14550
14551 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14552 PyObject *resultobj = 0;
14553 wxImage *arg1 = (wxImage *) 0 ;
14554 wxString *arg2 = 0 ;
14555 wxString *arg3 = 0 ;
14556 int arg4 = (int) -1 ;
14557 bool result;
14558 void *argp1 = 0 ;
14559 int res1 = 0 ;
14560 bool temp2 = false ;
14561 bool temp3 = false ;
14562 int val4 ;
14563 int ecode4 = 0 ;
14564 PyObject * obj0 = 0 ;
14565 PyObject * obj1 = 0 ;
14566 PyObject * obj2 = 0 ;
14567 PyObject * obj3 = 0 ;
14568 char * kwnames[] = {
14569 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14570 };
14571
14572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14574 if (!SWIG_IsOK(res1)) {
14575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14576 }
14577 arg1 = reinterpret_cast< wxImage * >(argp1);
14578 {
14579 arg2 = wxString_in_helper(obj1);
14580 if (arg2 == NULL) SWIG_fail;
14581 temp2 = true;
14582 }
14583 {
14584 arg3 = wxString_in_helper(obj2);
14585 if (arg3 == NULL) SWIG_fail;
14586 temp3 = true;
14587 }
14588 if (obj3) {
14589 ecode4 = SWIG_AsVal_int(obj3, &val4);
14590 if (!SWIG_IsOK(ecode4)) {
14591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14592 }
14593 arg4 = static_cast< int >(val4);
14594 }
14595 {
14596 PyThreadState* __tstate = wxPyBeginAllowThreads();
14597 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14598 wxPyEndAllowThreads(__tstate);
14599 if (PyErr_Occurred()) SWIG_fail;
14600 }
14601 {
14602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14603 }
14604 {
14605 if (temp2)
14606 delete arg2;
14607 }
14608 {
14609 if (temp3)
14610 delete arg3;
14611 }
14612 return resultobj;
14613 fail:
14614 {
14615 if (temp2)
14616 delete arg2;
14617 }
14618 {
14619 if (temp3)
14620 delete arg3;
14621 }
14622 return NULL;
14623 }
14624
14625
14626 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14627 PyObject *resultobj = 0;
14628 wxImage *arg1 = (wxImage *) 0 ;
14629 wxString *arg2 = 0 ;
14630 int arg3 ;
14631 bool result;
14632 void *argp1 = 0 ;
14633 int res1 = 0 ;
14634 bool temp2 = false ;
14635 int val3 ;
14636 int ecode3 = 0 ;
14637 PyObject * obj0 = 0 ;
14638 PyObject * obj1 = 0 ;
14639 PyObject * obj2 = 0 ;
14640 char * kwnames[] = {
14641 (char *) "self",(char *) "name",(char *) "type", NULL
14642 };
14643
14644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14646 if (!SWIG_IsOK(res1)) {
14647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14648 }
14649 arg1 = reinterpret_cast< wxImage * >(argp1);
14650 {
14651 arg2 = wxString_in_helper(obj1);
14652 if (arg2 == NULL) SWIG_fail;
14653 temp2 = true;
14654 }
14655 ecode3 = SWIG_AsVal_int(obj2, &val3);
14656 if (!SWIG_IsOK(ecode3)) {
14657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14658 }
14659 arg3 = static_cast< int >(val3);
14660 {
14661 PyThreadState* __tstate = wxPyBeginAllowThreads();
14662 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14663 wxPyEndAllowThreads(__tstate);
14664 if (PyErr_Occurred()) SWIG_fail;
14665 }
14666 {
14667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14668 }
14669 {
14670 if (temp2)
14671 delete arg2;
14672 }
14673 return resultobj;
14674 fail:
14675 {
14676 if (temp2)
14677 delete arg2;
14678 }
14679 return NULL;
14680 }
14681
14682
14683 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14684 PyObject *resultobj = 0;
14685 wxImage *arg1 = (wxImage *) 0 ;
14686 wxString *arg2 = 0 ;
14687 wxString *arg3 = 0 ;
14688 bool result;
14689 void *argp1 = 0 ;
14690 int res1 = 0 ;
14691 bool temp2 = false ;
14692 bool temp3 = false ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 char * kwnames[] = {
14697 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14698 };
14699
14700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14702 if (!SWIG_IsOK(res1)) {
14703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14704 }
14705 arg1 = reinterpret_cast< wxImage * >(argp1);
14706 {
14707 arg2 = wxString_in_helper(obj1);
14708 if (arg2 == NULL) SWIG_fail;
14709 temp2 = true;
14710 }
14711 {
14712 arg3 = wxString_in_helper(obj2);
14713 if (arg3 == NULL) SWIG_fail;
14714 temp3 = true;
14715 }
14716 {
14717 PyThreadState* __tstate = wxPyBeginAllowThreads();
14718 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14719 wxPyEndAllowThreads(__tstate);
14720 if (PyErr_Occurred()) SWIG_fail;
14721 }
14722 {
14723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14724 }
14725 {
14726 if (temp2)
14727 delete arg2;
14728 }
14729 {
14730 if (temp3)
14731 delete arg3;
14732 }
14733 return resultobj;
14734 fail:
14735 {
14736 if (temp2)
14737 delete arg2;
14738 }
14739 {
14740 if (temp3)
14741 delete arg3;
14742 }
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14748 PyObject *resultobj = 0;
14749 wxInputStream *arg1 = 0 ;
14750 bool result;
14751 wxPyInputStream *temp1 ;
14752 bool created1 ;
14753 PyObject * obj0 = 0 ;
14754 char * kwnames[] = {
14755 (char *) "stream", NULL
14756 };
14757
14758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14759 {
14760 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14761 arg1 = temp1->m_wxis;
14762 created1 = false;
14763 } else {
14764 PyErr_Clear(); // clear the failure of the wxPyConvert above
14765 arg1 = wxPyCBInputStream_create(obj0, false);
14766 if (arg1 == NULL) {
14767 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14768 SWIG_fail;
14769 }
14770 created1 = true;
14771 }
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)wxImage::CanRead(*arg1);
14776 wxPyEndAllowThreads(__tstate);
14777 if (PyErr_Occurred()) SWIG_fail;
14778 }
14779 {
14780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14781 }
14782 {
14783 if (created1) delete arg1;
14784 }
14785 return resultobj;
14786 fail:
14787 {
14788 if (created1) delete arg1;
14789 }
14790 return NULL;
14791 }
14792
14793
14794 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj = 0;
14796 wxImage *arg1 = (wxImage *) 0 ;
14797 wxInputStream *arg2 = 0 ;
14798 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14799 int arg4 = (int) -1 ;
14800 bool result;
14801 void *argp1 = 0 ;
14802 int res1 = 0 ;
14803 wxPyInputStream *temp2 ;
14804 bool created2 ;
14805 long val3 ;
14806 int ecode3 = 0 ;
14807 int val4 ;
14808 int ecode4 = 0 ;
14809 PyObject * obj0 = 0 ;
14810 PyObject * obj1 = 0 ;
14811 PyObject * obj2 = 0 ;
14812 PyObject * obj3 = 0 ;
14813 char * kwnames[] = {
14814 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14815 };
14816
14817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14819 if (!SWIG_IsOK(res1)) {
14820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14821 }
14822 arg1 = reinterpret_cast< wxImage * >(argp1);
14823 {
14824 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14825 arg2 = temp2->m_wxis;
14826 created2 = false;
14827 } else {
14828 PyErr_Clear(); // clear the failure of the wxPyConvert above
14829 arg2 = wxPyCBInputStream_create(obj1, false);
14830 if (arg2 == NULL) {
14831 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14832 SWIG_fail;
14833 }
14834 created2 = true;
14835 }
14836 }
14837 if (obj2) {
14838 ecode3 = SWIG_AsVal_long(obj2, &val3);
14839 if (!SWIG_IsOK(ecode3)) {
14840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14841 }
14842 arg3 = static_cast< long >(val3);
14843 }
14844 if (obj3) {
14845 ecode4 = SWIG_AsVal_int(obj3, &val4);
14846 if (!SWIG_IsOK(ecode4)) {
14847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14848 }
14849 arg4 = static_cast< int >(val4);
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 {
14861 if (created2) delete arg2;
14862 }
14863 return resultobj;
14864 fail:
14865 {
14866 if (created2) delete arg2;
14867 }
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14873 PyObject *resultobj = 0;
14874 wxImage *arg1 = (wxImage *) 0 ;
14875 wxInputStream *arg2 = 0 ;
14876 wxString *arg3 = 0 ;
14877 int arg4 = (int) -1 ;
14878 bool result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 wxPyInputStream *temp2 ;
14882 bool created2 ;
14883 bool temp3 = false ;
14884 int val4 ;
14885 int ecode4 = 0 ;
14886 PyObject * obj0 = 0 ;
14887 PyObject * obj1 = 0 ;
14888 PyObject * obj2 = 0 ;
14889 PyObject * obj3 = 0 ;
14890 char * kwnames[] = {
14891 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14892 };
14893
14894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14896 if (!SWIG_IsOK(res1)) {
14897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14898 }
14899 arg1 = reinterpret_cast< wxImage * >(argp1);
14900 {
14901 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14902 arg2 = temp2->m_wxis;
14903 created2 = false;
14904 } else {
14905 PyErr_Clear(); // clear the failure of the wxPyConvert above
14906 arg2 = wxPyCBInputStream_create(obj1, false);
14907 if (arg2 == NULL) {
14908 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14909 SWIG_fail;
14910 }
14911 created2 = true;
14912 }
14913 }
14914 {
14915 arg3 = wxString_in_helper(obj2);
14916 if (arg3 == NULL) SWIG_fail;
14917 temp3 = true;
14918 }
14919 if (obj3) {
14920 ecode4 = SWIG_AsVal_int(obj3, &val4);
14921 if (!SWIG_IsOK(ecode4)) {
14922 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14923 }
14924 arg4 = static_cast< int >(val4);
14925 }
14926 {
14927 PyThreadState* __tstate = wxPyBeginAllowThreads();
14928 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 {
14933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14934 }
14935 {
14936 if (created2) delete arg2;
14937 }
14938 {
14939 if (temp3)
14940 delete arg3;
14941 }
14942 return resultobj;
14943 fail:
14944 {
14945 if (created2) delete arg2;
14946 }
14947 {
14948 if (temp3)
14949 delete arg3;
14950 }
14951 return NULL;
14952 }
14953
14954
14955 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14956 PyObject *resultobj = 0;
14957 wxImage *arg1 = (wxImage *) 0 ;
14958 bool result;
14959 void *argp1 = 0 ;
14960 int res1 = 0 ;
14961 PyObject *swig_obj[1] ;
14962
14963 if (!args) SWIG_fail;
14964 swig_obj[0] = args;
14965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14968 }
14969 arg1 = reinterpret_cast< wxImage * >(argp1);
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (bool)(arg1)->Ok();
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 {
14977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14978 }
14979 return resultobj;
14980 fail:
14981 return NULL;
14982 }
14983
14984
14985 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14986 PyObject *resultobj = 0;
14987 wxImage *arg1 = (wxImage *) 0 ;
14988 int result;
14989 void *argp1 = 0 ;
14990 int res1 = 0 ;
14991 PyObject *swig_obj[1] ;
14992
14993 if (!args) SWIG_fail;
14994 swig_obj[0] = args;
14995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14996 if (!SWIG_IsOK(res1)) {
14997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14998 }
14999 arg1 = reinterpret_cast< wxImage * >(argp1);
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (int)(arg1)->GetWidth();
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_From_int(static_cast< int >(result));
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15014 PyObject *resultobj = 0;
15015 wxImage *arg1 = (wxImage *) 0 ;
15016 int result;
15017 void *argp1 = 0 ;
15018 int res1 = 0 ;
15019 PyObject *swig_obj[1] ;
15020
15021 if (!args) SWIG_fail;
15022 swig_obj[0] = args;
15023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15024 if (!SWIG_IsOK(res1)) {
15025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15026 }
15027 arg1 = reinterpret_cast< wxImage * >(argp1);
15028 {
15029 PyThreadState* __tstate = wxPyBeginAllowThreads();
15030 result = (int)(arg1)->GetHeight();
15031 wxPyEndAllowThreads(__tstate);
15032 if (PyErr_Occurred()) SWIG_fail;
15033 }
15034 resultobj = SWIG_From_int(static_cast< int >(result));
15035 return resultobj;
15036 fail:
15037 return NULL;
15038 }
15039
15040
15041 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15042 PyObject *resultobj = 0;
15043 wxImage *arg1 = (wxImage *) 0 ;
15044 wxSize result;
15045 void *argp1 = 0 ;
15046 int res1 = 0 ;
15047 PyObject *swig_obj[1] ;
15048
15049 if (!args) SWIG_fail;
15050 swig_obj[0] = args;
15051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15052 if (!SWIG_IsOK(res1)) {
15053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15054 }
15055 arg1 = reinterpret_cast< wxImage * >(argp1);
15056 {
15057 PyThreadState* __tstate = wxPyBeginAllowThreads();
15058 result = wxImage_GetSize(arg1);
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15063 return resultobj;
15064 fail:
15065 return NULL;
15066 }
15067
15068
15069 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15070 PyObject *resultobj = 0;
15071 wxImage *arg1 = (wxImage *) 0 ;
15072 wxRect *arg2 = 0 ;
15073 SwigValueWrapper<wxImage > result;
15074 void *argp1 = 0 ;
15075 int res1 = 0 ;
15076 wxRect temp2 ;
15077 PyObject * obj0 = 0 ;
15078 PyObject * obj1 = 0 ;
15079 char * kwnames[] = {
15080 (char *) "self",(char *) "rect", NULL
15081 };
15082
15083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15087 }
15088 arg1 = reinterpret_cast< wxImage * >(argp1);
15089 {
15090 arg2 = &temp2;
15091 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15092 }
15093 {
15094 PyThreadState* __tstate = wxPyBeginAllowThreads();
15095 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15107 PyObject *resultobj = 0;
15108 wxImage *arg1 = (wxImage *) 0 ;
15109 wxSize *arg2 = 0 ;
15110 wxPoint *arg3 = 0 ;
15111 int arg4 = (int) -1 ;
15112 int arg5 = (int) -1 ;
15113 int arg6 = (int) -1 ;
15114 SwigValueWrapper<wxImage > result;
15115 void *argp1 = 0 ;
15116 int res1 = 0 ;
15117 wxSize temp2 ;
15118 wxPoint temp3 ;
15119 int val4 ;
15120 int ecode4 = 0 ;
15121 int val5 ;
15122 int ecode5 = 0 ;
15123 int val6 ;
15124 int ecode6 = 0 ;
15125 PyObject * obj0 = 0 ;
15126 PyObject * obj1 = 0 ;
15127 PyObject * obj2 = 0 ;
15128 PyObject * obj3 = 0 ;
15129 PyObject * obj4 = 0 ;
15130 PyObject * obj5 = 0 ;
15131 char * kwnames[] = {
15132 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15133 };
15134
15135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15137 if (!SWIG_IsOK(res1)) {
15138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15139 }
15140 arg1 = reinterpret_cast< wxImage * >(argp1);
15141 {
15142 arg2 = &temp2;
15143 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15144 }
15145 {
15146 arg3 = &temp3;
15147 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15148 }
15149 if (obj3) {
15150 ecode4 = SWIG_AsVal_int(obj3, &val4);
15151 if (!SWIG_IsOK(ecode4)) {
15152 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15153 }
15154 arg4 = static_cast< int >(val4);
15155 }
15156 if (obj4) {
15157 ecode5 = SWIG_AsVal_int(obj4, &val5);
15158 if (!SWIG_IsOK(ecode5)) {
15159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15160 }
15161 arg5 = static_cast< int >(val5);
15162 }
15163 if (obj5) {
15164 ecode6 = SWIG_AsVal_int(obj5, &val6);
15165 if (!SWIG_IsOK(ecode6)) {
15166 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15167 }
15168 arg6 = static_cast< int >(val6);
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15177 return resultobj;
15178 fail:
15179 return NULL;
15180 }
15181
15182
15183 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15184 PyObject *resultobj = 0;
15185 wxImage *arg1 = (wxImage *) 0 ;
15186 SwigValueWrapper<wxImage > result;
15187 void *argp1 = 0 ;
15188 int res1 = 0 ;
15189 PyObject *swig_obj[1] ;
15190
15191 if (!args) SWIG_fail;
15192 swig_obj[0] = args;
15193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15194 if (!SWIG_IsOK(res1)) {
15195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15196 }
15197 arg1 = reinterpret_cast< wxImage * >(argp1);
15198 {
15199 PyThreadState* __tstate = wxPyBeginAllowThreads();
15200 result = (arg1)->Copy();
15201 wxPyEndAllowThreads(__tstate);
15202 if (PyErr_Occurred()) SWIG_fail;
15203 }
15204 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15205 return resultobj;
15206 fail:
15207 return NULL;
15208 }
15209
15210
15211 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15212 PyObject *resultobj = 0;
15213 wxImage *arg1 = (wxImage *) 0 ;
15214 wxImage *arg2 = 0 ;
15215 int arg3 ;
15216 int arg4 ;
15217 void *argp1 = 0 ;
15218 int res1 = 0 ;
15219 void *argp2 = 0 ;
15220 int res2 = 0 ;
15221 int val3 ;
15222 int ecode3 = 0 ;
15223 int val4 ;
15224 int ecode4 = 0 ;
15225 PyObject * obj0 = 0 ;
15226 PyObject * obj1 = 0 ;
15227 PyObject * obj2 = 0 ;
15228 PyObject * obj3 = 0 ;
15229 char * kwnames[] = {
15230 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15231 };
15232
15233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15235 if (!SWIG_IsOK(res1)) {
15236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15237 }
15238 arg1 = reinterpret_cast< wxImage * >(argp1);
15239 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15240 if (!SWIG_IsOK(res2)) {
15241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15242 }
15243 if (!argp2) {
15244 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15245 }
15246 arg2 = reinterpret_cast< wxImage * >(argp2);
15247 ecode3 = SWIG_AsVal_int(obj2, &val3);
15248 if (!SWIG_IsOK(ecode3)) {
15249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15250 }
15251 arg3 = static_cast< int >(val3);
15252 ecode4 = SWIG_AsVal_int(obj3, &val4);
15253 if (!SWIG_IsOK(ecode4)) {
15254 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15255 }
15256 arg4 = static_cast< int >(val4);
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15260 wxPyEndAllowThreads(__tstate);
15261 if (PyErr_Occurred()) SWIG_fail;
15262 }
15263 resultobj = SWIG_Py_Void();
15264 return resultobj;
15265 fail:
15266 return NULL;
15267 }
15268
15269
15270 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15271 PyObject *resultobj = 0;
15272 wxImage *arg1 = (wxImage *) 0 ;
15273 PyObject *result = 0 ;
15274 void *argp1 = 0 ;
15275 int res1 = 0 ;
15276 PyObject *swig_obj[1] ;
15277
15278 if (!args) SWIG_fail;
15279 swig_obj[0] = args;
15280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15281 if (!SWIG_IsOK(res1)) {
15282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15283 }
15284 arg1 = reinterpret_cast< wxImage * >(argp1);
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (PyObject *)wxImage_GetData(arg1);
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 resultobj = result;
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15299 PyObject *resultobj = 0;
15300 wxImage *arg1 = (wxImage *) 0 ;
15301 buffer arg2 ;
15302 int arg3 ;
15303 void *argp1 = 0 ;
15304 int res1 = 0 ;
15305 PyObject * obj0 = 0 ;
15306 PyObject * obj1 = 0 ;
15307 char * kwnames[] = {
15308 (char *) "self",(char *) "data", NULL
15309 };
15310
15311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15313 if (!SWIG_IsOK(res1)) {
15314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15315 }
15316 arg1 = reinterpret_cast< wxImage * >(argp1);
15317 {
15318 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15319 }
15320 {
15321 PyThreadState* __tstate = wxPyBeginAllowThreads();
15322 wxImage_SetData(arg1,arg2,arg3);
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 resultobj = SWIG_Py_Void();
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15334 PyObject *resultobj = 0;
15335 wxImage *arg1 = (wxImage *) 0 ;
15336 PyObject *result = 0 ;
15337 void *argp1 = 0 ;
15338 int res1 = 0 ;
15339 PyObject *swig_obj[1] ;
15340
15341 if (!args) SWIG_fail;
15342 swig_obj[0] = args;
15343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15344 if (!SWIG_IsOK(res1)) {
15345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15346 }
15347 arg1 = reinterpret_cast< wxImage * >(argp1);
15348 {
15349 PyThreadState* __tstate = wxPyBeginAllowThreads();
15350 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15351 wxPyEndAllowThreads(__tstate);
15352 if (PyErr_Occurred()) SWIG_fail;
15353 }
15354 resultobj = result;
15355 return resultobj;
15356 fail:
15357 return NULL;
15358 }
15359
15360
15361 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15362 PyObject *resultobj = 0;
15363 wxImage *arg1 = (wxImage *) 0 ;
15364 buffer arg2 ;
15365 int arg3 ;
15366 void *argp1 = 0 ;
15367 int res1 = 0 ;
15368 PyObject * obj0 = 0 ;
15369 PyObject * obj1 = 0 ;
15370 char * kwnames[] = {
15371 (char *) "self",(char *) "data", NULL
15372 };
15373
15374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15376 if (!SWIG_IsOK(res1)) {
15377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15378 }
15379 arg1 = reinterpret_cast< wxImage * >(argp1);
15380 {
15381 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15382 }
15383 {
15384 PyThreadState* __tstate = wxPyBeginAllowThreads();
15385 wxImage_SetDataBuffer(arg1,arg2,arg3);
15386 wxPyEndAllowThreads(__tstate);
15387 if (PyErr_Occurred()) SWIG_fail;
15388 }
15389 resultobj = SWIG_Py_Void();
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397 PyObject *resultobj = 0;
15398 wxImage *arg1 = (wxImage *) 0 ;
15399 PyObject *result = 0 ;
15400 void *argp1 = 0 ;
15401 int res1 = 0 ;
15402 PyObject *swig_obj[1] ;
15403
15404 if (!args) SWIG_fail;
15405 swig_obj[0] = args;
15406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15407 if (!SWIG_IsOK(res1)) {
15408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15409 }
15410 arg1 = reinterpret_cast< wxImage * >(argp1);
15411 {
15412 PyThreadState* __tstate = wxPyBeginAllowThreads();
15413 result = (PyObject *)wxImage_GetAlphaData(arg1);
15414 wxPyEndAllowThreads(__tstate);
15415 if (PyErr_Occurred()) SWIG_fail;
15416 }
15417 resultobj = result;
15418 return resultobj;
15419 fail:
15420 return NULL;
15421 }
15422
15423
15424 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15425 PyObject *resultobj = 0;
15426 wxImage *arg1 = (wxImage *) 0 ;
15427 buffer arg2 ;
15428 int arg3 ;
15429 void *argp1 = 0 ;
15430 int res1 = 0 ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 char * kwnames[] = {
15434 (char *) "self",(char *) "alpha", NULL
15435 };
15436
15437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15439 if (!SWIG_IsOK(res1)) {
15440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15441 }
15442 arg1 = reinterpret_cast< wxImage * >(argp1);
15443 {
15444 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15445 }
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 wxImage_SetAlphaData(arg1,arg2,arg3);
15449 wxPyEndAllowThreads(__tstate);
15450 if (PyErr_Occurred()) SWIG_fail;
15451 }
15452 resultobj = SWIG_Py_Void();
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *resultobj = 0;
15461 wxImage *arg1 = (wxImage *) 0 ;
15462 PyObject *result = 0 ;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 PyObject *swig_obj[1] ;
15466
15467 if (!args) SWIG_fail;
15468 swig_obj[0] = args;
15469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15472 }
15473 arg1 = reinterpret_cast< wxImage * >(argp1);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = result;
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxImage *arg1 = (wxImage *) 0 ;
15490 buffer arg2 ;
15491 int arg3 ;
15492 void *argp1 = 0 ;
15493 int res1 = 0 ;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "alpha", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15504 }
15505 arg1 = reinterpret_cast< wxImage * >(argp1);
15506 {
15507 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15508 }
15509 {
15510 PyThreadState* __tstate = wxPyBeginAllowThreads();
15511 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15523 PyObject *resultobj = 0;
15524 wxImage *arg1 = (wxImage *) 0 ;
15525 byte arg2 ;
15526 byte arg3 ;
15527 byte arg4 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 unsigned char val2 ;
15531 int ecode2 = 0 ;
15532 unsigned char val3 ;
15533 int ecode3 = 0 ;
15534 unsigned char val4 ;
15535 int ecode4 = 0 ;
15536 PyObject * obj0 = 0 ;
15537 PyObject * obj1 = 0 ;
15538 PyObject * obj2 = 0 ;
15539 PyObject * obj3 = 0 ;
15540 char * kwnames[] = {
15541 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15542 };
15543
15544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15546 if (!SWIG_IsOK(res1)) {
15547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15548 }
15549 arg1 = reinterpret_cast< wxImage * >(argp1);
15550 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15551 if (!SWIG_IsOK(ecode2)) {
15552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15553 }
15554 arg2 = static_cast< byte >(val2);
15555 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15556 if (!SWIG_IsOK(ecode3)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15558 }
15559 arg3 = static_cast< byte >(val3);
15560 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15561 if (!SWIG_IsOK(ecode4)) {
15562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15563 }
15564 arg4 = static_cast< byte >(val4);
15565 {
15566 PyThreadState* __tstate = wxPyBeginAllowThreads();
15567 (arg1)->SetMaskColour(arg2,arg3,arg4);
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 resultobj = SWIG_Py_Void();
15572 return resultobj;
15573 fail:
15574 return NULL;
15575 }
15576
15577
15578 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15579 PyObject *resultobj = 0;
15580 wxImage *arg1 = (wxImage *) 0 ;
15581 byte *arg2 = (byte *) 0 ;
15582 byte *arg3 = (byte *) 0 ;
15583 byte *arg4 = (byte *) 0 ;
15584 void *argp1 = 0 ;
15585 int res1 = 0 ;
15586 byte temp2 ;
15587 int res2 = SWIG_TMPOBJ ;
15588 byte temp3 ;
15589 int res3 = SWIG_TMPOBJ ;
15590 byte temp4 ;
15591 int res4 = SWIG_TMPOBJ ;
15592 PyObject *swig_obj[1] ;
15593
15594 arg2 = &temp2;
15595 arg3 = &temp3;
15596 arg4 = &temp4;
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15602 }
15603 arg1 = reinterpret_cast< wxImage * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 resultobj = SWIG_Py_Void();
15611 if (SWIG_IsTmpObj(res2)) {
15612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15613 } else {
15614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15616 }
15617 if (SWIG_IsTmpObj(res3)) {
15618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15619 } else {
15620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15622 }
15623 if (SWIG_IsTmpObj(res4)) {
15624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15625 } else {
15626 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15628 }
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *resultobj = 0;
15637 wxImage *arg1 = (wxImage *) 0 ;
15638 byte result;
15639 void *argp1 = 0 ;
15640 int res1 = 0 ;
15641 PyObject *swig_obj[1] ;
15642
15643 if (!args) SWIG_fail;
15644 swig_obj[0] = args;
15645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15646 if (!SWIG_IsOK(res1)) {
15647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15648 }
15649 arg1 = reinterpret_cast< wxImage * >(argp1);
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (byte)(arg1)->GetMaskRed();
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15657 return resultobj;
15658 fail:
15659 return NULL;
15660 }
15661
15662
15663 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15664 PyObject *resultobj = 0;
15665 wxImage *arg1 = (wxImage *) 0 ;
15666 byte result;
15667 void *argp1 = 0 ;
15668 int res1 = 0 ;
15669 PyObject *swig_obj[1] ;
15670
15671 if (!args) SWIG_fail;
15672 swig_obj[0] = args;
15673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15674 if (!SWIG_IsOK(res1)) {
15675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15676 }
15677 arg1 = reinterpret_cast< wxImage * >(argp1);
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (byte)(arg1)->GetMaskGreen();
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15685 return resultobj;
15686 fail:
15687 return NULL;
15688 }
15689
15690
15691 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15692 PyObject *resultobj = 0;
15693 wxImage *arg1 = (wxImage *) 0 ;
15694 byte result;
15695 void *argp1 = 0 ;
15696 int res1 = 0 ;
15697 PyObject *swig_obj[1] ;
15698
15699 if (!args) SWIG_fail;
15700 swig_obj[0] = args;
15701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15702 if (!SWIG_IsOK(res1)) {
15703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15704 }
15705 arg1 = reinterpret_cast< wxImage * >(argp1);
15706 {
15707 PyThreadState* __tstate = wxPyBeginAllowThreads();
15708 result = (byte)(arg1)->GetMaskBlue();
15709 wxPyEndAllowThreads(__tstate);
15710 if (PyErr_Occurred()) SWIG_fail;
15711 }
15712 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15713 return resultobj;
15714 fail:
15715 return NULL;
15716 }
15717
15718
15719 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15720 PyObject *resultobj = 0;
15721 wxImage *arg1 = (wxImage *) 0 ;
15722 bool arg2 = (bool) true ;
15723 void *argp1 = 0 ;
15724 int res1 = 0 ;
15725 bool val2 ;
15726 int ecode2 = 0 ;
15727 PyObject * obj0 = 0 ;
15728 PyObject * obj1 = 0 ;
15729 char * kwnames[] = {
15730 (char *) "self",(char *) "mask", NULL
15731 };
15732
15733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15735 if (!SWIG_IsOK(res1)) {
15736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15737 }
15738 arg1 = reinterpret_cast< wxImage * >(argp1);
15739 if (obj1) {
15740 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15741 if (!SWIG_IsOK(ecode2)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15743 }
15744 arg2 = static_cast< bool >(val2);
15745 }
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 (arg1)->SetMask(arg2);
15749 wxPyEndAllowThreads(__tstate);
15750 if (PyErr_Occurred()) SWIG_fail;
15751 }
15752 resultobj = SWIG_Py_Void();
15753 return resultobj;
15754 fail:
15755 return NULL;
15756 }
15757
15758
15759 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15760 PyObject *resultobj = 0;
15761 wxImage *arg1 = (wxImage *) 0 ;
15762 bool result;
15763 void *argp1 = 0 ;
15764 int res1 = 0 ;
15765 PyObject *swig_obj[1] ;
15766
15767 if (!args) SWIG_fail;
15768 swig_obj[0] = args;
15769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15770 if (!SWIG_IsOK(res1)) {
15771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15772 }
15773 arg1 = reinterpret_cast< wxImage * >(argp1);
15774 {
15775 PyThreadState* __tstate = wxPyBeginAllowThreads();
15776 result = (bool)(arg1)->HasMask();
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 {
15781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15782 }
15783 return resultobj;
15784 fail:
15785 return NULL;
15786 }
15787
15788
15789 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15790 PyObject *resultobj = 0;
15791 wxImage *arg1 = (wxImage *) 0 ;
15792 double arg2 ;
15793 wxPoint *arg3 = 0 ;
15794 bool arg4 = (bool) true ;
15795 wxPoint *arg5 = (wxPoint *) NULL ;
15796 SwigValueWrapper<wxImage > result;
15797 void *argp1 = 0 ;
15798 int res1 = 0 ;
15799 double val2 ;
15800 int ecode2 = 0 ;
15801 wxPoint temp3 ;
15802 bool val4 ;
15803 int ecode4 = 0 ;
15804 void *argp5 = 0 ;
15805 int res5 = 0 ;
15806 PyObject * obj0 = 0 ;
15807 PyObject * obj1 = 0 ;
15808 PyObject * obj2 = 0 ;
15809 PyObject * obj3 = 0 ;
15810 PyObject * obj4 = 0 ;
15811 char * kwnames[] = {
15812 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15813 };
15814
15815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15817 if (!SWIG_IsOK(res1)) {
15818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15819 }
15820 arg1 = reinterpret_cast< wxImage * >(argp1);
15821 ecode2 = SWIG_AsVal_double(obj1, &val2);
15822 if (!SWIG_IsOK(ecode2)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15824 }
15825 arg2 = static_cast< double >(val2);
15826 {
15827 arg3 = &temp3;
15828 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15829 }
15830 if (obj3) {
15831 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15832 if (!SWIG_IsOK(ecode4)) {
15833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15834 }
15835 arg4 = static_cast< bool >(val4);
15836 }
15837 if (obj4) {
15838 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15839 if (!SWIG_IsOK(res5)) {
15840 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15841 }
15842 arg5 = reinterpret_cast< wxPoint * >(argp5);
15843 }
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15847 wxPyEndAllowThreads(__tstate);
15848 if (PyErr_Occurred()) SWIG_fail;
15849 }
15850 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15851 return resultobj;
15852 fail:
15853 return NULL;
15854 }
15855
15856
15857 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15858 PyObject *resultobj = 0;
15859 wxImage *arg1 = (wxImage *) 0 ;
15860 bool arg2 = (bool) true ;
15861 SwigValueWrapper<wxImage > result;
15862 void *argp1 = 0 ;
15863 int res1 = 0 ;
15864 bool val2 ;
15865 int ecode2 = 0 ;
15866 PyObject * obj0 = 0 ;
15867 PyObject * obj1 = 0 ;
15868 char * kwnames[] = {
15869 (char *) "self",(char *) "clockwise", NULL
15870 };
15871
15872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15874 if (!SWIG_IsOK(res1)) {
15875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15876 }
15877 arg1 = reinterpret_cast< wxImage * >(argp1);
15878 if (obj1) {
15879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15880 if (!SWIG_IsOK(ecode2)) {
15881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15882 }
15883 arg2 = static_cast< bool >(val2);
15884 }
15885 {
15886 PyThreadState* __tstate = wxPyBeginAllowThreads();
15887 result = (arg1)->Rotate90(arg2);
15888 wxPyEndAllowThreads(__tstate);
15889 if (PyErr_Occurred()) SWIG_fail;
15890 }
15891 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15892 return resultobj;
15893 fail:
15894 return NULL;
15895 }
15896
15897
15898 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15899 PyObject *resultobj = 0;
15900 wxImage *arg1 = (wxImage *) 0 ;
15901 bool arg2 = (bool) true ;
15902 SwigValueWrapper<wxImage > result;
15903 void *argp1 = 0 ;
15904 int res1 = 0 ;
15905 bool val2 ;
15906 int ecode2 = 0 ;
15907 PyObject * obj0 = 0 ;
15908 PyObject * obj1 = 0 ;
15909 char * kwnames[] = {
15910 (char *) "self",(char *) "horizontally", NULL
15911 };
15912
15913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15915 if (!SWIG_IsOK(res1)) {
15916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15917 }
15918 arg1 = reinterpret_cast< wxImage * >(argp1);
15919 if (obj1) {
15920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15921 if (!SWIG_IsOK(ecode2)) {
15922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15923 }
15924 arg2 = static_cast< bool >(val2);
15925 }
15926 {
15927 PyThreadState* __tstate = wxPyBeginAllowThreads();
15928 result = (arg1)->Mirror(arg2);
15929 wxPyEndAllowThreads(__tstate);
15930 if (PyErr_Occurred()) SWIG_fail;
15931 }
15932 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15933 return resultobj;
15934 fail:
15935 return NULL;
15936 }
15937
15938
15939 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15940 PyObject *resultobj = 0;
15941 wxImage *arg1 = (wxImage *) 0 ;
15942 byte arg2 ;
15943 byte arg3 ;
15944 byte arg4 ;
15945 byte arg5 ;
15946 byte arg6 ;
15947 byte arg7 ;
15948 void *argp1 = 0 ;
15949 int res1 = 0 ;
15950 unsigned char val2 ;
15951 int ecode2 = 0 ;
15952 unsigned char val3 ;
15953 int ecode3 = 0 ;
15954 unsigned char val4 ;
15955 int ecode4 = 0 ;
15956 unsigned char val5 ;
15957 int ecode5 = 0 ;
15958 unsigned char val6 ;
15959 int ecode6 = 0 ;
15960 unsigned char val7 ;
15961 int ecode7 = 0 ;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 PyObject * obj2 = 0 ;
15965 PyObject * obj3 = 0 ;
15966 PyObject * obj4 = 0 ;
15967 PyObject * obj5 = 0 ;
15968 PyObject * obj6 = 0 ;
15969 char * kwnames[] = {
15970 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15971 };
15972
15973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15977 }
15978 arg1 = reinterpret_cast< wxImage * >(argp1);
15979 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15980 if (!SWIG_IsOK(ecode2)) {
15981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15982 }
15983 arg2 = static_cast< byte >(val2);
15984 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15985 if (!SWIG_IsOK(ecode3)) {
15986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15987 }
15988 arg3 = static_cast< byte >(val3);
15989 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15990 if (!SWIG_IsOK(ecode4)) {
15991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15992 }
15993 arg4 = static_cast< byte >(val4);
15994 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15995 if (!SWIG_IsOK(ecode5)) {
15996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15997 }
15998 arg5 = static_cast< byte >(val5);
15999 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16000 if (!SWIG_IsOK(ecode6)) {
16001 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16002 }
16003 arg6 = static_cast< byte >(val6);
16004 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16005 if (!SWIG_IsOK(ecode7)) {
16006 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16007 }
16008 arg7 = static_cast< byte >(val7);
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 resultobj = SWIG_Py_Void();
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = 0;
16024 wxImage *arg1 = (wxImage *) 0 ;
16025 double arg2 = (double) 0.299 ;
16026 double arg3 = (double) 0.587 ;
16027 double arg4 = (double) 0.114 ;
16028 SwigValueWrapper<wxImage > result;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 double val2 ;
16032 int ecode2 = 0 ;
16033 double val3 ;
16034 int ecode3 = 0 ;
16035 double val4 ;
16036 int ecode4 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 PyObject * obj2 = 0 ;
16040 PyObject * obj3 = 0 ;
16041 char * kwnames[] = {
16042 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16043 };
16044
16045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16049 }
16050 arg1 = reinterpret_cast< wxImage * >(argp1);
16051 if (obj1) {
16052 ecode2 = SWIG_AsVal_double(obj1, &val2);
16053 if (!SWIG_IsOK(ecode2)) {
16054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16055 }
16056 arg2 = static_cast< double >(val2);
16057 }
16058 if (obj2) {
16059 ecode3 = SWIG_AsVal_double(obj2, &val3);
16060 if (!SWIG_IsOK(ecode3)) {
16061 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16062 }
16063 arg3 = static_cast< double >(val3);
16064 }
16065 if (obj3) {
16066 ecode4 = SWIG_AsVal_double(obj3, &val4);
16067 if (!SWIG_IsOK(ecode4)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16069 }
16070 arg4 = static_cast< double >(val4);
16071 }
16072 {
16073 PyThreadState* __tstate = wxPyBeginAllowThreads();
16074 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16075 wxPyEndAllowThreads(__tstate);
16076 if (PyErr_Occurred()) SWIG_fail;
16077 }
16078 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16079 return resultobj;
16080 fail:
16081 return NULL;
16082 }
16083
16084
16085 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16086 PyObject *resultobj = 0;
16087 wxImage *arg1 = (wxImage *) 0 ;
16088 byte arg2 ;
16089 byte arg3 ;
16090 byte arg4 ;
16091 SwigValueWrapper<wxImage > result;
16092 void *argp1 = 0 ;
16093 int res1 = 0 ;
16094 unsigned char val2 ;
16095 int ecode2 = 0 ;
16096 unsigned char val3 ;
16097 int ecode3 = 0 ;
16098 unsigned char val4 ;
16099 int ecode4 = 0 ;
16100 PyObject * obj0 = 0 ;
16101 PyObject * obj1 = 0 ;
16102 PyObject * obj2 = 0 ;
16103 PyObject * obj3 = 0 ;
16104 char * kwnames[] = {
16105 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16106 };
16107
16108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16110 if (!SWIG_IsOK(res1)) {
16111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16112 }
16113 arg1 = reinterpret_cast< wxImage * >(argp1);
16114 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16115 if (!SWIG_IsOK(ecode2)) {
16116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16117 }
16118 arg2 = static_cast< byte >(val2);
16119 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16120 if (!SWIG_IsOK(ecode3)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16122 }
16123 arg3 = static_cast< byte >(val3);
16124 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16125 if (!SWIG_IsOK(ecode4)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16127 }
16128 arg4 = static_cast< byte >(val4);
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16132 wxPyEndAllowThreads(__tstate);
16133 if (PyErr_Occurred()) SWIG_fail;
16134 }
16135 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16136 return resultobj;
16137 fail:
16138 return NULL;
16139 }
16140
16141
16142 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16143 PyObject *resultobj = 0;
16144 wxImage *arg1 = (wxImage *) 0 ;
16145 wxString *arg2 = 0 ;
16146 wxString *arg3 = 0 ;
16147 void *argp1 = 0 ;
16148 int res1 = 0 ;
16149 bool temp2 = false ;
16150 bool temp3 = false ;
16151 PyObject * obj0 = 0 ;
16152 PyObject * obj1 = 0 ;
16153 PyObject * obj2 = 0 ;
16154 char * kwnames[] = {
16155 (char *) "self",(char *) "name",(char *) "value", NULL
16156 };
16157
16158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16160 if (!SWIG_IsOK(res1)) {
16161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16162 }
16163 arg1 = reinterpret_cast< wxImage * >(argp1);
16164 {
16165 arg2 = wxString_in_helper(obj1);
16166 if (arg2 == NULL) SWIG_fail;
16167 temp2 = true;
16168 }
16169 {
16170 arg3 = wxString_in_helper(obj2);
16171 if (arg3 == NULL) SWIG_fail;
16172 temp3 = true;
16173 }
16174 {
16175 PyThreadState* __tstate = wxPyBeginAllowThreads();
16176 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 resultobj = SWIG_Py_Void();
16181 {
16182 if (temp2)
16183 delete arg2;
16184 }
16185 {
16186 if (temp3)
16187 delete arg3;
16188 }
16189 return resultobj;
16190 fail:
16191 {
16192 if (temp2)
16193 delete arg2;
16194 }
16195 {
16196 if (temp3)
16197 delete arg3;
16198 }
16199 return NULL;
16200 }
16201
16202
16203 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16204 PyObject *resultobj = 0;
16205 wxImage *arg1 = (wxImage *) 0 ;
16206 wxString *arg2 = 0 ;
16207 int arg3 ;
16208 void *argp1 = 0 ;
16209 int res1 = 0 ;
16210 bool temp2 = false ;
16211 int val3 ;
16212 int ecode3 = 0 ;
16213 PyObject * obj0 = 0 ;
16214 PyObject * obj1 = 0 ;
16215 PyObject * obj2 = 0 ;
16216 char * kwnames[] = {
16217 (char *) "self",(char *) "name",(char *) "value", NULL
16218 };
16219
16220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16222 if (!SWIG_IsOK(res1)) {
16223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16224 }
16225 arg1 = reinterpret_cast< wxImage * >(argp1);
16226 {
16227 arg2 = wxString_in_helper(obj1);
16228 if (arg2 == NULL) SWIG_fail;
16229 temp2 = true;
16230 }
16231 ecode3 = SWIG_AsVal_int(obj2, &val3);
16232 if (!SWIG_IsOK(ecode3)) {
16233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16234 }
16235 arg3 = static_cast< int >(val3);
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 (arg1)->SetOption((wxString const &)*arg2,arg3);
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 resultobj = SWIG_Py_Void();
16243 {
16244 if (temp2)
16245 delete arg2;
16246 }
16247 return resultobj;
16248 fail:
16249 {
16250 if (temp2)
16251 delete arg2;
16252 }
16253 return NULL;
16254 }
16255
16256
16257 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16258 PyObject *resultobj = 0;
16259 wxImage *arg1 = (wxImage *) 0 ;
16260 wxString *arg2 = 0 ;
16261 wxString result;
16262 void *argp1 = 0 ;
16263 int res1 = 0 ;
16264 bool temp2 = false ;
16265 PyObject * obj0 = 0 ;
16266 PyObject * obj1 = 0 ;
16267 char * kwnames[] = {
16268 (char *) "self",(char *) "name", NULL
16269 };
16270
16271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16273 if (!SWIG_IsOK(res1)) {
16274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16275 }
16276 arg1 = reinterpret_cast< wxImage * >(argp1);
16277 {
16278 arg2 = wxString_in_helper(obj1);
16279 if (arg2 == NULL) SWIG_fail;
16280 temp2 = true;
16281 }
16282 {
16283 PyThreadState* __tstate = wxPyBeginAllowThreads();
16284 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16285 wxPyEndAllowThreads(__tstate);
16286 if (PyErr_Occurred()) SWIG_fail;
16287 }
16288 {
16289 #if wxUSE_UNICODE
16290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16291 #else
16292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16293 #endif
16294 }
16295 {
16296 if (temp2)
16297 delete arg2;
16298 }
16299 return resultobj;
16300 fail:
16301 {
16302 if (temp2)
16303 delete arg2;
16304 }
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxImage *arg1 = (wxImage *) 0 ;
16312 wxString *arg2 = 0 ;
16313 int result;
16314 void *argp1 = 0 ;
16315 int res1 = 0 ;
16316 bool temp2 = false ;
16317 PyObject * obj0 = 0 ;
16318 PyObject * obj1 = 0 ;
16319 char * kwnames[] = {
16320 (char *) "self",(char *) "name", NULL
16321 };
16322
16323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16325 if (!SWIG_IsOK(res1)) {
16326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16327 }
16328 arg1 = reinterpret_cast< wxImage * >(argp1);
16329 {
16330 arg2 = wxString_in_helper(obj1);
16331 if (arg2 == NULL) SWIG_fail;
16332 temp2 = true;
16333 }
16334 {
16335 PyThreadState* __tstate = wxPyBeginAllowThreads();
16336 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16337 wxPyEndAllowThreads(__tstate);
16338 if (PyErr_Occurred()) SWIG_fail;
16339 }
16340 resultobj = SWIG_From_int(static_cast< int >(result));
16341 {
16342 if (temp2)
16343 delete arg2;
16344 }
16345 return resultobj;
16346 fail:
16347 {
16348 if (temp2)
16349 delete arg2;
16350 }
16351 return NULL;
16352 }
16353
16354
16355 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16356 PyObject *resultobj = 0;
16357 wxImage *arg1 = (wxImage *) 0 ;
16358 wxString *arg2 = 0 ;
16359 bool result;
16360 void *argp1 = 0 ;
16361 int res1 = 0 ;
16362 bool temp2 = false ;
16363 PyObject * obj0 = 0 ;
16364 PyObject * obj1 = 0 ;
16365 char * kwnames[] = {
16366 (char *) "self",(char *) "name", NULL
16367 };
16368
16369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16371 if (!SWIG_IsOK(res1)) {
16372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16373 }
16374 arg1 = reinterpret_cast< wxImage * >(argp1);
16375 {
16376 arg2 = wxString_in_helper(obj1);
16377 if (arg2 == NULL) SWIG_fail;
16378 temp2 = true;
16379 }
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 {
16387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16388 }
16389 {
16390 if (temp2)
16391 delete arg2;
16392 }
16393 return resultobj;
16394 fail:
16395 {
16396 if (temp2)
16397 delete arg2;
16398 }
16399 return NULL;
16400 }
16401
16402
16403 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16404 PyObject *resultobj = 0;
16405 wxImage *arg1 = (wxImage *) 0 ;
16406 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16407 unsigned long result;
16408 void *argp1 = 0 ;
16409 int res1 = 0 ;
16410 unsigned long val2 ;
16411 int ecode2 = 0 ;
16412 PyObject * obj0 = 0 ;
16413 PyObject * obj1 = 0 ;
16414 char * kwnames[] = {
16415 (char *) "self",(char *) "stopafter", NULL
16416 };
16417
16418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16420 if (!SWIG_IsOK(res1)) {
16421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16422 }
16423 arg1 = reinterpret_cast< wxImage * >(argp1);
16424 if (obj1) {
16425 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16426 if (!SWIG_IsOK(ecode2)) {
16427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16428 }
16429 arg2 = static_cast< unsigned long >(val2);
16430 }
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 result = (unsigned long)(arg1)->CountColours(arg2);
16434 wxPyEndAllowThreads(__tstate);
16435 if (PyErr_Occurred()) SWIG_fail;
16436 }
16437 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16438 return resultobj;
16439 fail:
16440 return NULL;
16441 }
16442
16443
16444 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16445 PyObject *resultobj = 0;
16446 wxImage *arg1 = (wxImage *) 0 ;
16447 wxImageHistogram *arg2 = 0 ;
16448 unsigned long result;
16449 void *argp1 = 0 ;
16450 int res1 = 0 ;
16451 void *argp2 = 0 ;
16452 int res2 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 PyObject * obj1 = 0 ;
16455 char * kwnames[] = {
16456 (char *) "self",(char *) "h", NULL
16457 };
16458
16459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16461 if (!SWIG_IsOK(res1)) {
16462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16463 }
16464 arg1 = reinterpret_cast< wxImage * >(argp1);
16465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16466 if (!SWIG_IsOK(res2)) {
16467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16468 }
16469 if (!argp2) {
16470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16471 }
16472 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16473 {
16474 PyThreadState* __tstate = wxPyBeginAllowThreads();
16475 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16476 wxPyEndAllowThreads(__tstate);
16477 if (PyErr_Occurred()) SWIG_fail;
16478 }
16479 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16480 return resultobj;
16481 fail:
16482 return NULL;
16483 }
16484
16485
16486 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16487 PyObject *resultobj = 0;
16488 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 PyObject * obj0 = 0 ;
16492 char * kwnames[] = {
16493 (char *) "handler", NULL
16494 };
16495
16496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16498 if (!SWIG_IsOK(res1)) {
16499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16500 }
16501 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16502 {
16503 PyThreadState* __tstate = wxPyBeginAllowThreads();
16504 wxImage::AddHandler(arg1);
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_Py_Void();
16509 return resultobj;
16510 fail:
16511 return NULL;
16512 }
16513
16514
16515 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16516 PyObject *resultobj = 0;
16517 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 PyObject * obj0 = 0 ;
16521 char * kwnames[] = {
16522 (char *) "handler", NULL
16523 };
16524
16525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16527 if (!SWIG_IsOK(res1)) {
16528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16529 }
16530 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 wxImage::InsertHandler(arg1);
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 resultobj = SWIG_Py_Void();
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj = 0;
16546 wxString *arg1 = 0 ;
16547 bool result;
16548 bool temp1 = false ;
16549 PyObject * obj0 = 0 ;
16550 char * kwnames[] = {
16551 (char *) "name", NULL
16552 };
16553
16554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16555 {
16556 arg1 = wxString_in_helper(obj0);
16557 if (arg1 == NULL) SWIG_fail;
16558 temp1 = true;
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 {
16567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16568 }
16569 {
16570 if (temp1)
16571 delete arg1;
16572 }
16573 return resultobj;
16574 fail:
16575 {
16576 if (temp1)
16577 delete arg1;
16578 }
16579 return NULL;
16580 }
16581
16582
16583 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16584 PyObject *resultobj = 0;
16585 PyObject *result = 0 ;
16586
16587 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16588 {
16589 PyThreadState* __tstate = wxPyBeginAllowThreads();
16590 result = (PyObject *)wxImage_GetHandlers();
16591 wxPyEndAllowThreads(__tstate);
16592 if (PyErr_Occurred()) SWIG_fail;
16593 }
16594 resultobj = result;
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16602 PyObject *resultobj = 0;
16603 wxString result;
16604
16605 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = wxImage::GetImageExtWildcard();
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 {
16613 #if wxUSE_UNICODE
16614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16615 #else
16616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16617 #endif
16618 }
16619 return resultobj;
16620 fail:
16621 return NULL;
16622 }
16623
16624
16625 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16626 PyObject *resultobj = 0;
16627 wxImage *arg1 = (wxImage *) 0 ;
16628 int arg2 = (int) -1 ;
16629 wxBitmap result;
16630 void *argp1 = 0 ;
16631 int res1 = 0 ;
16632 int val2 ;
16633 int ecode2 = 0 ;
16634 PyObject * obj0 = 0 ;
16635 PyObject * obj1 = 0 ;
16636 char * kwnames[] = {
16637 (char *) "self",(char *) "depth", NULL
16638 };
16639
16640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16642 if (!SWIG_IsOK(res1)) {
16643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16644 }
16645 arg1 = reinterpret_cast< wxImage * >(argp1);
16646 if (obj1) {
16647 ecode2 = SWIG_AsVal_int(obj1, &val2);
16648 if (!SWIG_IsOK(ecode2)) {
16649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16650 }
16651 arg2 = static_cast< int >(val2);
16652 }
16653 {
16654 if (!wxPyCheckForApp()) SWIG_fail;
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = wxImage_ConvertToBitmap(arg1,arg2);
16657 wxPyEndAllowThreads(__tstate);
16658 if (PyErr_Occurred()) SWIG_fail;
16659 }
16660 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16661 return resultobj;
16662 fail:
16663 return NULL;
16664 }
16665
16666
16667 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16668 PyObject *resultobj = 0;
16669 wxImage *arg1 = (wxImage *) 0 ;
16670 byte arg2 ;
16671 byte arg3 ;
16672 byte arg4 ;
16673 wxBitmap result;
16674 void *argp1 = 0 ;
16675 int res1 = 0 ;
16676 unsigned char val2 ;
16677 int ecode2 = 0 ;
16678 unsigned char val3 ;
16679 int ecode3 = 0 ;
16680 unsigned char val4 ;
16681 int ecode4 = 0 ;
16682 PyObject * obj0 = 0 ;
16683 PyObject * obj1 = 0 ;
16684 PyObject * obj2 = 0 ;
16685 PyObject * obj3 = 0 ;
16686 char * kwnames[] = {
16687 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16688 };
16689
16690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16692 if (!SWIG_IsOK(res1)) {
16693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16694 }
16695 arg1 = reinterpret_cast< wxImage * >(argp1);
16696 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16697 if (!SWIG_IsOK(ecode2)) {
16698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16699 }
16700 arg2 = static_cast< byte >(val2);
16701 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16702 if (!SWIG_IsOK(ecode3)) {
16703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16704 }
16705 arg3 = static_cast< byte >(val3);
16706 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16707 if (!SWIG_IsOK(ecode4)) {
16708 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16709 }
16710 arg4 = static_cast< byte >(val4);
16711 {
16712 if (!wxPyCheckForApp()) SWIG_fail;
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16715 wxPyEndAllowThreads(__tstate);
16716 if (PyErr_Occurred()) SWIG_fail;
16717 }
16718 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16719 return resultobj;
16720 fail:
16721 return NULL;
16722 }
16723
16724
16725 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16726 PyObject *resultobj = 0;
16727 wxImage *arg1 = (wxImage *) 0 ;
16728 double arg2 ;
16729 void *argp1 = 0 ;
16730 int res1 = 0 ;
16731 double val2 ;
16732 int ecode2 = 0 ;
16733 PyObject * obj0 = 0 ;
16734 PyObject * obj1 = 0 ;
16735 char * kwnames[] = {
16736 (char *) "self",(char *) "angle", NULL
16737 };
16738
16739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16743 }
16744 arg1 = reinterpret_cast< wxImage * >(argp1);
16745 ecode2 = SWIG_AsVal_double(obj1, &val2);
16746 if (!SWIG_IsOK(ecode2)) {
16747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16748 }
16749 arg2 = static_cast< double >(val2);
16750 {
16751 PyThreadState* __tstate = wxPyBeginAllowThreads();
16752 (arg1)->RotateHue(arg2);
16753 wxPyEndAllowThreads(__tstate);
16754 if (PyErr_Occurred()) SWIG_fail;
16755 }
16756 resultobj = SWIG_Py_Void();
16757 return resultobj;
16758 fail:
16759 return NULL;
16760 }
16761
16762
16763 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16764 PyObject *resultobj = 0;
16765 wxImage_RGBValue arg1 ;
16766 wxImage_HSVValue result;
16767 void *argp1 ;
16768 int res1 = 0 ;
16769 PyObject * obj0 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "rgb", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16775 {
16776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16777 if (!SWIG_IsOK(res1)) {
16778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16779 }
16780 if (!argp1) {
16781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16782 } else {
16783 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16784 arg1 = *temp;
16785 if (SWIG_IsNewObj(res1)) delete temp;
16786 }
16787 }
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 result = wxImage::RGBtoHSV(arg1);
16791 wxPyEndAllowThreads(__tstate);
16792 if (PyErr_Occurred()) SWIG_fail;
16793 }
16794 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16795 return resultobj;
16796 fail:
16797 return NULL;
16798 }
16799
16800
16801 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16802 PyObject *resultobj = 0;
16803 wxImage_HSVValue arg1 ;
16804 wxImage_RGBValue result;
16805 void *argp1 ;
16806 int res1 = 0 ;
16807 PyObject * obj0 = 0 ;
16808 char * kwnames[] = {
16809 (char *) "hsv", NULL
16810 };
16811
16812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16813 {
16814 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16815 if (!SWIG_IsOK(res1)) {
16816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16817 }
16818 if (!argp1) {
16819 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16820 } else {
16821 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16822 arg1 = *temp;
16823 if (SWIG_IsNewObj(res1)) delete temp;
16824 }
16825 }
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = wxImage::HSVtoRGB(arg1);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16833 return resultobj;
16834 fail:
16835 return NULL;
16836 }
16837
16838
16839 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16840 PyObject *obj;
16841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16842 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16843 return SWIG_Py_Void();
16844 }
16845
16846 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16847 return SWIG_Python_InitShadowInstance(args);
16848 }
16849
16850 SWIGINTERN int NullImage_set(PyObject *) {
16851 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16852 return 1;
16853 }
16854
16855
16856 SWIGINTERN PyObject *NullImage_get(void) {
16857 PyObject *pyobj = 0;
16858
16859 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16860 return pyobj;
16861 }
16862
16863
16864 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16865 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16866 return 1;
16867 }
16868
16869
16870 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16871 PyObject *pyobj = 0;
16872
16873 {
16874 #if wxUSE_UNICODE
16875 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16876 #else
16877 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16878 #endif
16879 }
16880 return pyobj;
16881 }
16882
16883
16884 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16885 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16886 return 1;
16887 }
16888
16889
16890 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16891 PyObject *pyobj = 0;
16892
16893 {
16894 #if wxUSE_UNICODE
16895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16896 #else
16897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16898 #endif
16899 }
16900 return pyobj;
16901 }
16902
16903
16904 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16905 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16906 return 1;
16907 }
16908
16909
16910 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16911 PyObject *pyobj = 0;
16912
16913 {
16914 #if wxUSE_UNICODE
16915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16916 #else
16917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16918 #endif
16919 }
16920 return pyobj;
16921 }
16922
16923
16924 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16925 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16926 return 1;
16927 }
16928
16929
16930 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16931 PyObject *pyobj = 0;
16932
16933 {
16934 #if wxUSE_UNICODE
16935 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16936 #else
16937 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16938 #endif
16939 }
16940 return pyobj;
16941 }
16942
16943
16944 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16945 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16946 return 1;
16947 }
16948
16949
16950 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16951 PyObject *pyobj = 0;
16952
16953 {
16954 #if wxUSE_UNICODE
16955 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16956 #else
16957 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16958 #endif
16959 }
16960 return pyobj;
16961 }
16962
16963
16964 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16965 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16966 return 1;
16967 }
16968
16969
16970 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16971 PyObject *pyobj = 0;
16972
16973 {
16974 #if wxUSE_UNICODE
16975 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16976 #else
16977 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16978 #endif
16979 }
16980 return pyobj;
16981 }
16982
16983
16984 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16985 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16986 return 1;
16987 }
16988
16989
16990 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16991 PyObject *pyobj = 0;
16992
16993 {
16994 #if wxUSE_UNICODE
16995 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16996 #else
16997 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16998 #endif
16999 }
17000 return pyobj;
17001 }
17002
17003
17004 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17005 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17006 return 1;
17007 }
17008
17009
17010 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17011 PyObject *pyobj = 0;
17012
17013 {
17014 #if wxUSE_UNICODE
17015 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17016 #else
17017 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17018 #endif
17019 }
17020 return pyobj;
17021 }
17022
17023
17024 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17025 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17026 return 1;
17027 }
17028
17029
17030 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17031 PyObject *pyobj = 0;
17032
17033 {
17034 #if wxUSE_UNICODE
17035 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17036 #else
17037 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17038 #endif
17039 }
17040 return pyobj;
17041 }
17042
17043
17044 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17045 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17046 return 1;
17047 }
17048
17049
17050 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17051 PyObject *pyobj = 0;
17052
17053 {
17054 #if wxUSE_UNICODE
17055 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17056 #else
17057 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17058 #endif
17059 }
17060 return pyobj;
17061 }
17062
17063
17064 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17065 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17066 return 1;
17067 }
17068
17069
17070 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17071 PyObject *pyobj = 0;
17072
17073 {
17074 #if wxUSE_UNICODE
17075 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17076 #else
17077 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17078 #endif
17079 }
17080 return pyobj;
17081 }
17082
17083
17084 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17085 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17086 return 1;
17087 }
17088
17089
17090 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17091 PyObject *pyobj = 0;
17092
17093 {
17094 #if wxUSE_UNICODE
17095 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17096 #else
17097 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17098 #endif
17099 }
17100 return pyobj;
17101 }
17102
17103
17104 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17105 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17106 return 1;
17107 }
17108
17109
17110 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17111 PyObject *pyobj = 0;
17112
17113 {
17114 #if wxUSE_UNICODE
17115 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17116 #else
17117 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17118 #endif
17119 }
17120 return pyobj;
17121 }
17122
17123
17124 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17125 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17126 return 1;
17127 }
17128
17129
17130 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17131 PyObject *pyobj = 0;
17132
17133 {
17134 #if wxUSE_UNICODE
17135 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17136 #else
17137 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17138 #endif
17139 }
17140 return pyobj;
17141 }
17142
17143
17144 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17145 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17146 return 1;
17147 }
17148
17149
17150 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17151 PyObject *pyobj = 0;
17152
17153 {
17154 #if wxUSE_UNICODE
17155 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17156 #else
17157 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17158 #endif
17159 }
17160 return pyobj;
17161 }
17162
17163
17164 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17165 PyObject *resultobj = 0;
17166 wxBMPHandler *result = 0 ;
17167
17168 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17169 {
17170 PyThreadState* __tstate = wxPyBeginAllowThreads();
17171 result = (wxBMPHandler *)new wxBMPHandler();
17172 wxPyEndAllowThreads(__tstate);
17173 if (PyErr_Occurred()) SWIG_fail;
17174 }
17175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17176 return resultobj;
17177 fail:
17178 return NULL;
17179 }
17180
17181
17182 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17183 PyObject *obj;
17184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17185 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17186 return SWIG_Py_Void();
17187 }
17188
17189 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17190 return SWIG_Python_InitShadowInstance(args);
17191 }
17192
17193 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17194 PyObject *resultobj = 0;
17195 wxICOHandler *result = 0 ;
17196
17197 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17198 {
17199 PyThreadState* __tstate = wxPyBeginAllowThreads();
17200 result = (wxICOHandler *)new wxICOHandler();
17201 wxPyEndAllowThreads(__tstate);
17202 if (PyErr_Occurred()) SWIG_fail;
17203 }
17204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17212 PyObject *obj;
17213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17214 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17215 return SWIG_Py_Void();
17216 }
17217
17218 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17219 return SWIG_Python_InitShadowInstance(args);
17220 }
17221
17222 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17223 PyObject *resultobj = 0;
17224 wxCURHandler *result = 0 ;
17225
17226 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17227 {
17228 PyThreadState* __tstate = wxPyBeginAllowThreads();
17229 result = (wxCURHandler *)new wxCURHandler();
17230 wxPyEndAllowThreads(__tstate);
17231 if (PyErr_Occurred()) SWIG_fail;
17232 }
17233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17234 return resultobj;
17235 fail:
17236 return NULL;
17237 }
17238
17239
17240 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17241 PyObject *obj;
17242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17243 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17244 return SWIG_Py_Void();
17245 }
17246
17247 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17248 return SWIG_Python_InitShadowInstance(args);
17249 }
17250
17251 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17252 PyObject *resultobj = 0;
17253 wxANIHandler *result = 0 ;
17254
17255 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17256 {
17257 PyThreadState* __tstate = wxPyBeginAllowThreads();
17258 result = (wxANIHandler *)new wxANIHandler();
17259 wxPyEndAllowThreads(__tstate);
17260 if (PyErr_Occurred()) SWIG_fail;
17261 }
17262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17263 return resultobj;
17264 fail:
17265 return NULL;
17266 }
17267
17268
17269 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17270 PyObject *obj;
17271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17272 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17273 return SWIG_Py_Void();
17274 }
17275
17276 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17277 return SWIG_Python_InitShadowInstance(args);
17278 }
17279
17280 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17281 PyObject *resultobj = 0;
17282 wxPNGHandler *result = 0 ;
17283
17284 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17285 {
17286 PyThreadState* __tstate = wxPyBeginAllowThreads();
17287 result = (wxPNGHandler *)new wxPNGHandler();
17288 wxPyEndAllowThreads(__tstate);
17289 if (PyErr_Occurred()) SWIG_fail;
17290 }
17291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17292 return resultobj;
17293 fail:
17294 return NULL;
17295 }
17296
17297
17298 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17299 PyObject *obj;
17300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17301 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17302 return SWIG_Py_Void();
17303 }
17304
17305 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17306 return SWIG_Python_InitShadowInstance(args);
17307 }
17308
17309 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17310 PyObject *resultobj = 0;
17311 wxGIFHandler *result = 0 ;
17312
17313 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17314 {
17315 PyThreadState* __tstate = wxPyBeginAllowThreads();
17316 result = (wxGIFHandler *)new wxGIFHandler();
17317 wxPyEndAllowThreads(__tstate);
17318 if (PyErr_Occurred()) SWIG_fail;
17319 }
17320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17321 return resultobj;
17322 fail:
17323 return NULL;
17324 }
17325
17326
17327 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17328 PyObject *obj;
17329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17330 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17331 return SWIG_Py_Void();
17332 }
17333
17334 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17335 return SWIG_Python_InitShadowInstance(args);
17336 }
17337
17338 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17339 PyObject *resultobj = 0;
17340 wxPCXHandler *result = 0 ;
17341
17342 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17343 {
17344 PyThreadState* __tstate = wxPyBeginAllowThreads();
17345 result = (wxPCXHandler *)new wxPCXHandler();
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17357 PyObject *obj;
17358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17359 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17360 return SWIG_Py_Void();
17361 }
17362
17363 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17364 return SWIG_Python_InitShadowInstance(args);
17365 }
17366
17367 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17368 PyObject *resultobj = 0;
17369 wxJPEGHandler *result = 0 ;
17370
17371 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (wxJPEGHandler *)new wxJPEGHandler();
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17379 return resultobj;
17380 fail:
17381 return NULL;
17382 }
17383
17384
17385 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17386 PyObject *obj;
17387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17388 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17389 return SWIG_Py_Void();
17390 }
17391
17392 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17393 return SWIG_Python_InitShadowInstance(args);
17394 }
17395
17396 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17397 PyObject *resultobj = 0;
17398 wxPNMHandler *result = 0 ;
17399
17400 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17401 {
17402 PyThreadState* __tstate = wxPyBeginAllowThreads();
17403 result = (wxPNMHandler *)new wxPNMHandler();
17404 wxPyEndAllowThreads(__tstate);
17405 if (PyErr_Occurred()) SWIG_fail;
17406 }
17407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17408 return resultobj;
17409 fail:
17410 return NULL;
17411 }
17412
17413
17414 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 PyObject *obj;
17416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17417 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17418 return SWIG_Py_Void();
17419 }
17420
17421 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17422 return SWIG_Python_InitShadowInstance(args);
17423 }
17424
17425 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17426 PyObject *resultobj = 0;
17427 wxXPMHandler *result = 0 ;
17428
17429 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17430 {
17431 PyThreadState* __tstate = wxPyBeginAllowThreads();
17432 result = (wxXPMHandler *)new wxXPMHandler();
17433 wxPyEndAllowThreads(__tstate);
17434 if (PyErr_Occurred()) SWIG_fail;
17435 }
17436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17437 return resultobj;
17438 fail:
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *obj;
17445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17446 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17447 return SWIG_Py_Void();
17448 }
17449
17450 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17451 return SWIG_Python_InitShadowInstance(args);
17452 }
17453
17454 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17455 PyObject *resultobj = 0;
17456 wxTIFFHandler *result = 0 ;
17457
17458 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17459 {
17460 PyThreadState* __tstate = wxPyBeginAllowThreads();
17461 result = (wxTIFFHandler *)new wxTIFFHandler();
17462 wxPyEndAllowThreads(__tstate);
17463 if (PyErr_Occurred()) SWIG_fail;
17464 }
17465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 PyObject *obj;
17474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17475 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17476 return SWIG_Py_Void();
17477 }
17478
17479 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17480 return SWIG_Python_InitShadowInstance(args);
17481 }
17482
17483 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17484 PyObject *resultobj = 0;
17485 wxImage *arg1 = 0 ;
17486 wxImage *arg2 = 0 ;
17487 int arg3 = (int) 236 ;
17488 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17489 bool result;
17490 void *argp1 = 0 ;
17491 int res1 = 0 ;
17492 void *argp2 = 0 ;
17493 int res2 = 0 ;
17494 int val3 ;
17495 int ecode3 = 0 ;
17496 int val4 ;
17497 int ecode4 = 0 ;
17498 PyObject * obj0 = 0 ;
17499 PyObject * obj1 = 0 ;
17500 PyObject * obj2 = 0 ;
17501 PyObject * obj3 = 0 ;
17502 char * kwnames[] = {
17503 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17504 };
17505
17506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17507 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17508 if (!SWIG_IsOK(res1)) {
17509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17510 }
17511 if (!argp1) {
17512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17513 }
17514 arg1 = reinterpret_cast< wxImage * >(argp1);
17515 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17516 if (!SWIG_IsOK(res2)) {
17517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17518 }
17519 if (!argp2) {
17520 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17521 }
17522 arg2 = reinterpret_cast< wxImage * >(argp2);
17523 if (obj2) {
17524 ecode3 = SWIG_AsVal_int(obj2, &val3);
17525 if (!SWIG_IsOK(ecode3)) {
17526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17527 }
17528 arg3 = static_cast< int >(val3);
17529 }
17530 if (obj3) {
17531 ecode4 = SWIG_AsVal_int(obj3, &val4);
17532 if (!SWIG_IsOK(ecode4)) {
17533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17534 }
17535 arg4 = static_cast< int >(val4);
17536 }
17537 {
17538 PyThreadState* __tstate = wxPyBeginAllowThreads();
17539 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 {
17544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17545 }
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17553 PyObject *obj;
17554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17555 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17556 return SWIG_Py_Void();
17557 }
17558
17559 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17560 PyObject *resultobj = 0;
17561 wxEvtHandler *result = 0 ;
17562
17563 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17564 {
17565 PyThreadState* __tstate = wxPyBeginAllowThreads();
17566 result = (wxEvtHandler *)new wxEvtHandler();
17567 wxPyEndAllowThreads(__tstate);
17568 if (PyErr_Occurred()) SWIG_fail;
17569 }
17570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17571 return resultobj;
17572 fail:
17573 return NULL;
17574 }
17575
17576
17577 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *resultobj = 0;
17579 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17580 wxEvtHandler *result = 0 ;
17581 void *argp1 = 0 ;
17582 int res1 = 0 ;
17583 PyObject *swig_obj[1] ;
17584
17585 if (!args) SWIG_fail;
17586 swig_obj[0] = args;
17587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17588 if (!SWIG_IsOK(res1)) {
17589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17590 }
17591 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 {
17599 resultobj = wxPyMake_wxObject(result, 0);
17600 }
17601 return resultobj;
17602 fail:
17603 return NULL;
17604 }
17605
17606
17607 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17608 PyObject *resultobj = 0;
17609 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17610 wxEvtHandler *result = 0 ;
17611 void *argp1 = 0 ;
17612 int res1 = 0 ;
17613 PyObject *swig_obj[1] ;
17614
17615 if (!args) SWIG_fail;
17616 swig_obj[0] = args;
17617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17618 if (!SWIG_IsOK(res1)) {
17619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17620 }
17621 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 {
17629 resultobj = wxPyMake_wxObject(result, 0);
17630 }
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17638 PyObject *resultobj = 0;
17639 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17640 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17641 void *argp1 = 0 ;
17642 int res1 = 0 ;
17643 void *argp2 = 0 ;
17644 int res2 = 0 ;
17645 PyObject * obj0 = 0 ;
17646 PyObject * obj1 = 0 ;
17647 char * kwnames[] = {
17648 (char *) "self",(char *) "handler", NULL
17649 };
17650
17651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17653 if (!SWIG_IsOK(res1)) {
17654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17655 }
17656 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17658 if (!SWIG_IsOK(res2)) {
17659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17660 }
17661 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17662 {
17663 PyThreadState* __tstate = wxPyBeginAllowThreads();
17664 (arg1)->SetNextHandler(arg2);
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 resultobj = SWIG_Py_Void();
17669 return resultobj;
17670 fail:
17671 return NULL;
17672 }
17673
17674
17675 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17676 PyObject *resultobj = 0;
17677 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17678 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17679 void *argp1 = 0 ;
17680 int res1 = 0 ;
17681 void *argp2 = 0 ;
17682 int res2 = 0 ;
17683 PyObject * obj0 = 0 ;
17684 PyObject * obj1 = 0 ;
17685 char * kwnames[] = {
17686 (char *) "self",(char *) "handler", NULL
17687 };
17688
17689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17691 if (!SWIG_IsOK(res1)) {
17692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17693 }
17694 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17696 if (!SWIG_IsOK(res2)) {
17697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17698 }
17699 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17700 {
17701 PyThreadState* __tstate = wxPyBeginAllowThreads();
17702 (arg1)->SetPreviousHandler(arg2);
17703 wxPyEndAllowThreads(__tstate);
17704 if (PyErr_Occurred()) SWIG_fail;
17705 }
17706 resultobj = SWIG_Py_Void();
17707 return resultobj;
17708 fail:
17709 return NULL;
17710 }
17711
17712
17713 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17714 PyObject *resultobj = 0;
17715 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17716 bool result;
17717 void *argp1 = 0 ;
17718 int res1 = 0 ;
17719 PyObject *swig_obj[1] ;
17720
17721 if (!args) SWIG_fail;
17722 swig_obj[0] = args;
17723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17724 if (!SWIG_IsOK(res1)) {
17725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17726 }
17727 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 result = (bool)(arg1)->GetEvtHandlerEnabled();
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 return resultobj;
17738 fail:
17739 return NULL;
17740 }
17741
17742
17743 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17744 PyObject *resultobj = 0;
17745 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17746 bool arg2 ;
17747 void *argp1 = 0 ;
17748 int res1 = 0 ;
17749 bool val2 ;
17750 int ecode2 = 0 ;
17751 PyObject * obj0 = 0 ;
17752 PyObject * obj1 = 0 ;
17753 char * kwnames[] = {
17754 (char *) "self",(char *) "enabled", NULL
17755 };
17756
17757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17759 if (!SWIG_IsOK(res1)) {
17760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17761 }
17762 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17763 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17764 if (!SWIG_IsOK(ecode2)) {
17765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17766 }
17767 arg2 = static_cast< bool >(val2);
17768 {
17769 PyThreadState* __tstate = wxPyBeginAllowThreads();
17770 (arg1)->SetEvtHandlerEnabled(arg2);
17771 wxPyEndAllowThreads(__tstate);
17772 if (PyErr_Occurred()) SWIG_fail;
17773 }
17774 resultobj = SWIG_Py_Void();
17775 return resultobj;
17776 fail:
17777 return NULL;
17778 }
17779
17780
17781 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17782 PyObject *resultobj = 0;
17783 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17784 wxEvent *arg2 = 0 ;
17785 bool result;
17786 void *argp1 = 0 ;
17787 int res1 = 0 ;
17788 void *argp2 = 0 ;
17789 int res2 = 0 ;
17790 PyObject * obj0 = 0 ;
17791 PyObject * obj1 = 0 ;
17792 char * kwnames[] = {
17793 (char *) "self",(char *) "event", NULL
17794 };
17795
17796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17798 if (!SWIG_IsOK(res1)) {
17799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17800 }
17801 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17802 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17803 if (!SWIG_IsOK(res2)) {
17804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17805 }
17806 if (!argp2) {
17807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17808 }
17809 arg2 = reinterpret_cast< wxEvent * >(argp2);
17810 {
17811 PyThreadState* __tstate = wxPyBeginAllowThreads();
17812 result = (bool)(arg1)->ProcessEvent(*arg2);
17813 wxPyEndAllowThreads(__tstate);
17814 if (PyErr_Occurred()) SWIG_fail;
17815 }
17816 {
17817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17818 }
17819 return resultobj;
17820 fail:
17821 return NULL;
17822 }
17823
17824
17825 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17826 PyObject *resultobj = 0;
17827 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17828 wxEvent *arg2 = 0 ;
17829 void *argp1 = 0 ;
17830 int res1 = 0 ;
17831 void *argp2 = 0 ;
17832 int res2 = 0 ;
17833 PyObject * obj0 = 0 ;
17834 PyObject * obj1 = 0 ;
17835 char * kwnames[] = {
17836 (char *) "self",(char *) "event", NULL
17837 };
17838
17839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17841 if (!SWIG_IsOK(res1)) {
17842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17843 }
17844 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17845 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17846 if (!SWIG_IsOK(res2)) {
17847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17848 }
17849 if (!argp2) {
17850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17851 }
17852 arg2 = reinterpret_cast< wxEvent * >(argp2);
17853 {
17854 PyThreadState* __tstate = wxPyBeginAllowThreads();
17855 (arg1)->AddPendingEvent(*arg2);
17856 wxPyEndAllowThreads(__tstate);
17857 if (PyErr_Occurred()) SWIG_fail;
17858 }
17859 resultobj = SWIG_Py_Void();
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17867 PyObject *resultobj = 0;
17868 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17869 void *argp1 = 0 ;
17870 int res1 = 0 ;
17871 PyObject *swig_obj[1] ;
17872
17873 if (!args) SWIG_fail;
17874 swig_obj[0] = args;
17875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17876 if (!SWIG_IsOK(res1)) {
17877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17878 }
17879 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 (arg1)->ProcessPendingEvents();
17883 wxPyEndAllowThreads(__tstate);
17884 if (PyErr_Occurred()) SWIG_fail;
17885 }
17886 resultobj = SWIG_Py_Void();
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj = 0;
17895 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17896 int arg2 ;
17897 int arg3 ;
17898 int arg4 ;
17899 PyObject *arg5 = (PyObject *) 0 ;
17900 void *argp1 = 0 ;
17901 int res1 = 0 ;
17902 int val2 ;
17903 int ecode2 = 0 ;
17904 int val3 ;
17905 int ecode3 = 0 ;
17906 int val4 ;
17907 int ecode4 = 0 ;
17908 PyObject * obj0 = 0 ;
17909 PyObject * obj1 = 0 ;
17910 PyObject * obj2 = 0 ;
17911 PyObject * obj3 = 0 ;
17912 PyObject * obj4 = 0 ;
17913 char * kwnames[] = {
17914 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17915 };
17916
17917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17919 if (!SWIG_IsOK(res1)) {
17920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17921 }
17922 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17923 ecode2 = SWIG_AsVal_int(obj1, &val2);
17924 if (!SWIG_IsOK(ecode2)) {
17925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17926 }
17927 arg2 = static_cast< int >(val2);
17928 ecode3 = SWIG_AsVal_int(obj2, &val3);
17929 if (!SWIG_IsOK(ecode3)) {
17930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17931 }
17932 arg3 = static_cast< int >(val3);
17933 ecode4 = SWIG_AsVal_int(obj3, &val4);
17934 if (!SWIG_IsOK(ecode4)) {
17935 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17936 }
17937 arg4 = static_cast< int >(val4);
17938 arg5 = obj4;
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17942 wxPyEndAllowThreads(__tstate);
17943 if (PyErr_Occurred()) SWIG_fail;
17944 }
17945 resultobj = SWIG_Py_Void();
17946 return resultobj;
17947 fail:
17948 return NULL;
17949 }
17950
17951
17952 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17953 PyObject *resultobj = 0;
17954 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17955 int arg2 ;
17956 int arg3 = (int) -1 ;
17957 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17958 bool result;
17959 void *argp1 = 0 ;
17960 int res1 = 0 ;
17961 int val2 ;
17962 int ecode2 = 0 ;
17963 int val3 ;
17964 int ecode3 = 0 ;
17965 int val4 ;
17966 int ecode4 = 0 ;
17967 PyObject * obj0 = 0 ;
17968 PyObject * obj1 = 0 ;
17969 PyObject * obj2 = 0 ;
17970 PyObject * obj3 = 0 ;
17971 char * kwnames[] = {
17972 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17973 };
17974
17975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17977 if (!SWIG_IsOK(res1)) {
17978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17979 }
17980 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17981 ecode2 = SWIG_AsVal_int(obj1, &val2);
17982 if (!SWIG_IsOK(ecode2)) {
17983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17984 }
17985 arg2 = static_cast< int >(val2);
17986 if (obj2) {
17987 ecode3 = SWIG_AsVal_int(obj2, &val3);
17988 if (!SWIG_IsOK(ecode3)) {
17989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17990 }
17991 arg3 = static_cast< int >(val3);
17992 }
17993 if (obj3) {
17994 ecode4 = SWIG_AsVal_int(obj3, &val4);
17995 if (!SWIG_IsOK(ecode4)) {
17996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17997 }
17998 arg4 = static_cast< wxEventType >(val4);
17999 }
18000 {
18001 PyThreadState* __tstate = wxPyBeginAllowThreads();
18002 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18003 wxPyEndAllowThreads(__tstate);
18004 if (PyErr_Occurred()) SWIG_fail;
18005 }
18006 {
18007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18008 }
18009 return resultobj;
18010 fail:
18011 return NULL;
18012 }
18013
18014
18015 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18016 PyObject *resultobj = 0;
18017 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18018 PyObject *arg2 = (PyObject *) 0 ;
18019 bool arg3 = (bool) true ;
18020 void *argp1 = 0 ;
18021 int res1 = 0 ;
18022 bool val3 ;
18023 int ecode3 = 0 ;
18024 PyObject * obj0 = 0 ;
18025 PyObject * obj1 = 0 ;
18026 PyObject * obj2 = 0 ;
18027 char * kwnames[] = {
18028 (char *) "self",(char *) "_self",(char *) "incref", NULL
18029 };
18030
18031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18033 if (!SWIG_IsOK(res1)) {
18034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18035 }
18036 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18037 arg2 = obj1;
18038 if (obj2) {
18039 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18040 if (!SWIG_IsOK(ecode3)) {
18041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18042 }
18043 arg3 = static_cast< bool >(val3);
18044 }
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 resultobj = SWIG_Py_Void();
18052 return resultobj;
18053 fail:
18054 return NULL;
18055 }
18056
18057
18058 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18059 PyObject *obj;
18060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18061 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18062 return SWIG_Py_Void();
18063 }
18064
18065 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18066 return SWIG_Python_InitShadowInstance(args);
18067 }
18068
18069 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18070 PyObject *resultobj = 0;
18071 wxEventType result;
18072
18073 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (wxEventType)wxNewEventType();
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_From_int(static_cast< int >(result));
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 PyObject *resultobj = 0;
18089 wxEvent *arg1 = (wxEvent *) 0 ;
18090 void *argp1 = 0 ;
18091 int res1 = 0 ;
18092 PyObject *swig_obj[1] ;
18093
18094 if (!args) SWIG_fail;
18095 swig_obj[0] = args;
18096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18097 if (!SWIG_IsOK(res1)) {
18098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18099 }
18100 arg1 = reinterpret_cast< wxEvent * >(argp1);
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 delete arg1;
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 resultobj = SWIG_Py_Void();
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18116 PyObject *resultobj = 0;
18117 wxEvent *arg1 = (wxEvent *) 0 ;
18118 wxEventType arg2 ;
18119 void *argp1 = 0 ;
18120 int res1 = 0 ;
18121 int val2 ;
18122 int ecode2 = 0 ;
18123 PyObject * obj0 = 0 ;
18124 PyObject * obj1 = 0 ;
18125 char * kwnames[] = {
18126 (char *) "self",(char *) "typ", NULL
18127 };
18128
18129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18131 if (!SWIG_IsOK(res1)) {
18132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18133 }
18134 arg1 = reinterpret_cast< wxEvent * >(argp1);
18135 ecode2 = SWIG_AsVal_int(obj1, &val2);
18136 if (!SWIG_IsOK(ecode2)) {
18137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18138 }
18139 arg2 = static_cast< wxEventType >(val2);
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 (arg1)->SetEventType(arg2);
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_Py_Void();
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *resultobj = 0;
18155 wxEvent *arg1 = (wxEvent *) 0 ;
18156 wxEventType result;
18157 void *argp1 = 0 ;
18158 int res1 = 0 ;
18159 PyObject *swig_obj[1] ;
18160
18161 if (!args) SWIG_fail;
18162 swig_obj[0] = args;
18163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18164 if (!SWIG_IsOK(res1)) {
18165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18166 }
18167 arg1 = reinterpret_cast< wxEvent * >(argp1);
18168 {
18169 PyThreadState* __tstate = wxPyBeginAllowThreads();
18170 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18171 wxPyEndAllowThreads(__tstate);
18172 if (PyErr_Occurred()) SWIG_fail;
18173 }
18174 resultobj = SWIG_From_int(static_cast< int >(result));
18175 return resultobj;
18176 fail:
18177 return NULL;
18178 }
18179
18180
18181 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18182 PyObject *resultobj = 0;
18183 wxEvent *arg1 = (wxEvent *) 0 ;
18184 wxObject *result = 0 ;
18185 void *argp1 = 0 ;
18186 int res1 = 0 ;
18187 PyObject *swig_obj[1] ;
18188
18189 if (!args) SWIG_fail;
18190 swig_obj[0] = args;
18191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18192 if (!SWIG_IsOK(res1)) {
18193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18194 }
18195 arg1 = reinterpret_cast< wxEvent * >(argp1);
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 {
18203 resultobj = wxPyMake_wxObject(result, (bool)0);
18204 }
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18212 PyObject *resultobj = 0;
18213 wxEvent *arg1 = (wxEvent *) 0 ;
18214 wxObject *arg2 = (wxObject *) 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 void *argp2 = 0 ;
18218 int res2 = 0 ;
18219 PyObject * obj0 = 0 ;
18220 PyObject * obj1 = 0 ;
18221 char * kwnames[] = {
18222 (char *) "self",(char *) "obj", NULL
18223 };
18224
18225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18227 if (!SWIG_IsOK(res1)) {
18228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18229 }
18230 arg1 = reinterpret_cast< wxEvent * >(argp1);
18231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18232 if (!SWIG_IsOK(res2)) {
18233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18234 }
18235 arg2 = reinterpret_cast< wxObject * >(argp2);
18236 {
18237 PyThreadState* __tstate = wxPyBeginAllowThreads();
18238 (arg1)->SetEventObject(arg2);
18239 wxPyEndAllowThreads(__tstate);
18240 if (PyErr_Occurred()) SWIG_fail;
18241 }
18242 resultobj = SWIG_Py_Void();
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18250 PyObject *resultobj = 0;
18251 wxEvent *arg1 = (wxEvent *) 0 ;
18252 long result;
18253 void *argp1 = 0 ;
18254 int res1 = 0 ;
18255 PyObject *swig_obj[1] ;
18256
18257 if (!args) SWIG_fail;
18258 swig_obj[0] = args;
18259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18260 if (!SWIG_IsOK(res1)) {
18261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18262 }
18263 arg1 = reinterpret_cast< wxEvent * >(argp1);
18264 {
18265 PyThreadState* __tstate = wxPyBeginAllowThreads();
18266 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 resultobj = SWIG_From_long(static_cast< long >(result));
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = 0;
18279 wxEvent *arg1 = (wxEvent *) 0 ;
18280 long arg2 = (long) 0 ;
18281 void *argp1 = 0 ;
18282 int res1 = 0 ;
18283 long val2 ;
18284 int ecode2 = 0 ;
18285 PyObject * obj0 = 0 ;
18286 PyObject * obj1 = 0 ;
18287 char * kwnames[] = {
18288 (char *) "self",(char *) "ts", NULL
18289 };
18290
18291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 if (obj1) {
18298 ecode2 = SWIG_AsVal_long(obj1, &val2);
18299 if (!SWIG_IsOK(ecode2)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18301 }
18302 arg2 = static_cast< long >(val2);
18303 }
18304 {
18305 PyThreadState* __tstate = wxPyBeginAllowThreads();
18306 (arg1)->SetTimestamp(arg2);
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 resultobj = SWIG_Py_Void();
18311 return resultobj;
18312 fail:
18313 return NULL;
18314 }
18315
18316
18317 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18318 PyObject *resultobj = 0;
18319 wxEvent *arg1 = (wxEvent *) 0 ;
18320 int result;
18321 void *argp1 = 0 ;
18322 int res1 = 0 ;
18323 PyObject *swig_obj[1] ;
18324
18325 if (!args) SWIG_fail;
18326 swig_obj[0] = args;
18327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18328 if (!SWIG_IsOK(res1)) {
18329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18330 }
18331 arg1 = reinterpret_cast< wxEvent * >(argp1);
18332 {
18333 PyThreadState* __tstate = wxPyBeginAllowThreads();
18334 result = (int)((wxEvent const *)arg1)->GetId();
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 resultobj = SWIG_From_int(static_cast< int >(result));
18339 return resultobj;
18340 fail:
18341 return NULL;
18342 }
18343
18344
18345 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18346 PyObject *resultobj = 0;
18347 wxEvent *arg1 = (wxEvent *) 0 ;
18348 int arg2 ;
18349 void *argp1 = 0 ;
18350 int res1 = 0 ;
18351 int val2 ;
18352 int ecode2 = 0 ;
18353 PyObject * obj0 = 0 ;
18354 PyObject * obj1 = 0 ;
18355 char * kwnames[] = {
18356 (char *) "self",(char *) "Id", NULL
18357 };
18358
18359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18361 if (!SWIG_IsOK(res1)) {
18362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18363 }
18364 arg1 = reinterpret_cast< wxEvent * >(argp1);
18365 ecode2 = SWIG_AsVal_int(obj1, &val2);
18366 if (!SWIG_IsOK(ecode2)) {
18367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18368 }
18369 arg2 = static_cast< int >(val2);
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 (arg1)->SetId(arg2);
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 resultobj = SWIG_Py_Void();
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18384 PyObject *resultobj = 0;
18385 wxEvent *arg1 = (wxEvent *) 0 ;
18386 bool result;
18387 void *argp1 = 0 ;
18388 int res1 = 0 ;
18389 PyObject *swig_obj[1] ;
18390
18391 if (!args) SWIG_fail;
18392 swig_obj[0] = args;
18393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18394 if (!SWIG_IsOK(res1)) {
18395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18396 }
18397 arg1 = reinterpret_cast< wxEvent * >(argp1);
18398 {
18399 PyThreadState* __tstate = wxPyBeginAllowThreads();
18400 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18401 wxPyEndAllowThreads(__tstate);
18402 if (PyErr_Occurred()) SWIG_fail;
18403 }
18404 {
18405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18406 }
18407 return resultobj;
18408 fail:
18409 return NULL;
18410 }
18411
18412
18413 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj = 0;
18415 wxEvent *arg1 = (wxEvent *) 0 ;
18416 bool arg2 = (bool) true ;
18417 void *argp1 = 0 ;
18418 int res1 = 0 ;
18419 bool val2 ;
18420 int ecode2 = 0 ;
18421 PyObject * obj0 = 0 ;
18422 PyObject * obj1 = 0 ;
18423 char * kwnames[] = {
18424 (char *) "self",(char *) "skip", NULL
18425 };
18426
18427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18429 if (!SWIG_IsOK(res1)) {
18430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18431 }
18432 arg1 = reinterpret_cast< wxEvent * >(argp1);
18433 if (obj1) {
18434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18435 if (!SWIG_IsOK(ecode2)) {
18436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18437 }
18438 arg2 = static_cast< bool >(val2);
18439 }
18440 {
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 (arg1)->Skip(arg2);
18443 wxPyEndAllowThreads(__tstate);
18444 if (PyErr_Occurred()) SWIG_fail;
18445 }
18446 resultobj = SWIG_Py_Void();
18447 return resultobj;
18448 fail:
18449 return NULL;
18450 }
18451
18452
18453 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18454 PyObject *resultobj = 0;
18455 wxEvent *arg1 = (wxEvent *) 0 ;
18456 bool result;
18457 void *argp1 = 0 ;
18458 int res1 = 0 ;
18459 PyObject *swig_obj[1] ;
18460
18461 if (!args) SWIG_fail;
18462 swig_obj[0] = args;
18463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18464 if (!SWIG_IsOK(res1)) {
18465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18466 }
18467 arg1 = reinterpret_cast< wxEvent * >(argp1);
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 {
18475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18476 }
18477 return resultobj;
18478 fail:
18479 return NULL;
18480 }
18481
18482
18483 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18484 PyObject *resultobj = 0;
18485 wxEvent *arg1 = (wxEvent *) 0 ;
18486 bool result;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 PyObject *swig_obj[1] ;
18490
18491 if (!args) SWIG_fail;
18492 swig_obj[0] = args;
18493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18494 if (!SWIG_IsOK(res1)) {
18495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18496 }
18497 arg1 = reinterpret_cast< wxEvent * >(argp1);
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 {
18505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18506 }
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18514 PyObject *resultobj = 0;
18515 wxEvent *arg1 = (wxEvent *) 0 ;
18516 int result;
18517 void *argp1 = 0 ;
18518 int res1 = 0 ;
18519 PyObject *swig_obj[1] ;
18520
18521 if (!args) SWIG_fail;
18522 swig_obj[0] = args;
18523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18526 }
18527 arg1 = reinterpret_cast< wxEvent * >(argp1);
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (int)(arg1)->StopPropagation();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 resultobj = SWIG_From_int(static_cast< int >(result));
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18542 PyObject *resultobj = 0;
18543 wxEvent *arg1 = (wxEvent *) 0 ;
18544 int arg2 ;
18545 void *argp1 = 0 ;
18546 int res1 = 0 ;
18547 int val2 ;
18548 int ecode2 = 0 ;
18549 PyObject * obj0 = 0 ;
18550 PyObject * obj1 = 0 ;
18551 char * kwnames[] = {
18552 (char *) "self",(char *) "propagationLevel", NULL
18553 };
18554
18555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18557 if (!SWIG_IsOK(res1)) {
18558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18559 }
18560 arg1 = reinterpret_cast< wxEvent * >(argp1);
18561 ecode2 = SWIG_AsVal_int(obj1, &val2);
18562 if (!SWIG_IsOK(ecode2)) {
18563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18564 }
18565 arg2 = static_cast< int >(val2);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 (arg1)->ResumePropagation(arg2);
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 resultobj = SWIG_Py_Void();
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxEvent *arg1 = (wxEvent *) 0 ;
18582 wxEvent *result = 0 ;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18592 }
18593 arg1 = reinterpret_cast< wxEvent * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (wxEvent *)(arg1)->Clone();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18608 PyObject *obj;
18609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18610 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18611 return SWIG_Py_Void();
18612 }
18613
18614 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18615 PyObject *resultobj = 0;
18616 wxEvent *arg1 = 0 ;
18617 wxPropagationDisabler *result = 0 ;
18618 void *argp1 = 0 ;
18619 int res1 = 0 ;
18620 PyObject * obj0 = 0 ;
18621 char * kwnames[] = {
18622 (char *) "event", NULL
18623 };
18624
18625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18626 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18627 if (!SWIG_IsOK(res1)) {
18628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18629 }
18630 if (!argp1) {
18631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18632 }
18633 arg1 = reinterpret_cast< wxEvent * >(argp1);
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18648 PyObject *resultobj = 0;
18649 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18650 void *argp1 = 0 ;
18651 int res1 = 0 ;
18652 PyObject *swig_obj[1] ;
18653
18654 if (!args) SWIG_fail;
18655 swig_obj[0] = args;
18656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18657 if (!SWIG_IsOK(res1)) {
18658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18659 }
18660 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18661 {
18662 PyThreadState* __tstate = wxPyBeginAllowThreads();
18663 delete arg1;
18664
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 resultobj = SWIG_Py_Void();
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18676 PyObject *obj;
18677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18678 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18679 return SWIG_Py_Void();
18680 }
18681
18682 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18683 return SWIG_Python_InitShadowInstance(args);
18684 }
18685
18686 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18687 PyObject *resultobj = 0;
18688 wxEvent *arg1 = 0 ;
18689 wxPropagateOnce *result = 0 ;
18690 void *argp1 = 0 ;
18691 int res1 = 0 ;
18692 PyObject * obj0 = 0 ;
18693 char * kwnames[] = {
18694 (char *) "event", NULL
18695 };
18696
18697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18698 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18699 if (!SWIG_IsOK(res1)) {
18700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18701 }
18702 if (!argp1) {
18703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18704 }
18705 arg1 = reinterpret_cast< wxEvent * >(argp1);
18706 {
18707 PyThreadState* __tstate = wxPyBeginAllowThreads();
18708 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18709 wxPyEndAllowThreads(__tstate);
18710 if (PyErr_Occurred()) SWIG_fail;
18711 }
18712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18720 PyObject *resultobj = 0;
18721 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18722 void *argp1 = 0 ;
18723 int res1 = 0 ;
18724 PyObject *swig_obj[1] ;
18725
18726 if (!args) SWIG_fail;
18727 swig_obj[0] = args;
18728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18729 if (!SWIG_IsOK(res1)) {
18730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18731 }
18732 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 delete arg1;
18736
18737 wxPyEndAllowThreads(__tstate);
18738 if (PyErr_Occurred()) SWIG_fail;
18739 }
18740 resultobj = SWIG_Py_Void();
18741 return resultobj;
18742 fail:
18743 return NULL;
18744 }
18745
18746
18747 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18748 PyObject *obj;
18749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18750 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18751 return SWIG_Py_Void();
18752 }
18753
18754 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18755 return SWIG_Python_InitShadowInstance(args);
18756 }
18757
18758 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18759 PyObject *resultobj = 0;
18760 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18761 int arg2 = (int) 0 ;
18762 wxCommandEvent *result = 0 ;
18763 int val1 ;
18764 int ecode1 = 0 ;
18765 int val2 ;
18766 int ecode2 = 0 ;
18767 PyObject * obj0 = 0 ;
18768 PyObject * obj1 = 0 ;
18769 char * kwnames[] = {
18770 (char *) "commandType",(char *) "winid", NULL
18771 };
18772
18773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18774 if (obj0) {
18775 ecode1 = SWIG_AsVal_int(obj0, &val1);
18776 if (!SWIG_IsOK(ecode1)) {
18777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18778 }
18779 arg1 = static_cast< wxEventType >(val1);
18780 }
18781 if (obj1) {
18782 ecode2 = SWIG_AsVal_int(obj1, &val2);
18783 if (!SWIG_IsOK(ecode2)) {
18784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18785 }
18786 arg2 = static_cast< int >(val2);
18787 }
18788 {
18789 PyThreadState* __tstate = wxPyBeginAllowThreads();
18790 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18791 wxPyEndAllowThreads(__tstate);
18792 if (PyErr_Occurred()) SWIG_fail;
18793 }
18794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18795 return resultobj;
18796 fail:
18797 return NULL;
18798 }
18799
18800
18801 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18802 PyObject *resultobj = 0;
18803 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18804 int result;
18805 void *argp1 = 0 ;
18806 int res1 = 0 ;
18807 PyObject *swig_obj[1] ;
18808
18809 if (!args) SWIG_fail;
18810 swig_obj[0] = args;
18811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18812 if (!SWIG_IsOK(res1)) {
18813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18814 }
18815 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 resultobj = SWIG_From_int(static_cast< int >(result));
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18830 PyObject *resultobj = 0;
18831 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18832 wxString *arg2 = 0 ;
18833 void *argp1 = 0 ;
18834 int res1 = 0 ;
18835 bool temp2 = false ;
18836 PyObject * obj0 = 0 ;
18837 PyObject * obj1 = 0 ;
18838 char * kwnames[] = {
18839 (char *) "self",(char *) "s", NULL
18840 };
18841
18842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18844 if (!SWIG_IsOK(res1)) {
18845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18846 }
18847 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18848 {
18849 arg2 = wxString_in_helper(obj1);
18850 if (arg2 == NULL) SWIG_fail;
18851 temp2 = true;
18852 }
18853 {
18854 PyThreadState* __tstate = wxPyBeginAllowThreads();
18855 (arg1)->SetString((wxString const &)*arg2);
18856 wxPyEndAllowThreads(__tstate);
18857 if (PyErr_Occurred()) SWIG_fail;
18858 }
18859 resultobj = SWIG_Py_Void();
18860 {
18861 if (temp2)
18862 delete arg2;
18863 }
18864 return resultobj;
18865 fail:
18866 {
18867 if (temp2)
18868 delete arg2;
18869 }
18870 return NULL;
18871 }
18872
18873
18874 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18875 PyObject *resultobj = 0;
18876 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18877 wxString result;
18878 void *argp1 = 0 ;
18879 int res1 = 0 ;
18880 PyObject *swig_obj[1] ;
18881
18882 if (!args) SWIG_fail;
18883 swig_obj[0] = args;
18884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18885 if (!SWIG_IsOK(res1)) {
18886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18887 }
18888 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18889 {
18890 PyThreadState* __tstate = wxPyBeginAllowThreads();
18891 result = ((wxCommandEvent const *)arg1)->GetString();
18892 wxPyEndAllowThreads(__tstate);
18893 if (PyErr_Occurred()) SWIG_fail;
18894 }
18895 {
18896 #if wxUSE_UNICODE
18897 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18898 #else
18899 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18900 #endif
18901 }
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18909 PyObject *resultobj = 0;
18910 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18911 bool result;
18912 void *argp1 = 0 ;
18913 int res1 = 0 ;
18914 PyObject *swig_obj[1] ;
18915
18916 if (!args) SWIG_fail;
18917 swig_obj[0] = args;
18918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18919 if (!SWIG_IsOK(res1)) {
18920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18921 }
18922 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 {
18930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18931 }
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18939 PyObject *resultobj = 0;
18940 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18941 bool result;
18942 void *argp1 = 0 ;
18943 int res1 = 0 ;
18944 PyObject *swig_obj[1] ;
18945
18946 if (!args) SWIG_fail;
18947 swig_obj[0] = args;
18948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18951 }
18952 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 {
18960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18961 }
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18969 PyObject *resultobj = 0;
18970 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18971 long arg2 ;
18972 void *argp1 = 0 ;
18973 int res1 = 0 ;
18974 long val2 ;
18975 int ecode2 = 0 ;
18976 PyObject * obj0 = 0 ;
18977 PyObject * obj1 = 0 ;
18978 char * kwnames[] = {
18979 (char *) "self",(char *) "extraLong", NULL
18980 };
18981
18982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18984 if (!SWIG_IsOK(res1)) {
18985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18986 }
18987 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18988 ecode2 = SWIG_AsVal_long(obj1, &val2);
18989 if (!SWIG_IsOK(ecode2)) {
18990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18991 }
18992 arg2 = static_cast< long >(val2);
18993 {
18994 PyThreadState* __tstate = wxPyBeginAllowThreads();
18995 (arg1)->SetExtraLong(arg2);
18996 wxPyEndAllowThreads(__tstate);
18997 if (PyErr_Occurred()) SWIG_fail;
18998 }
18999 resultobj = SWIG_Py_Void();
19000 return resultobj;
19001 fail:
19002 return NULL;
19003 }
19004
19005
19006 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19007 PyObject *resultobj = 0;
19008 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19009 long result;
19010 void *argp1 = 0 ;
19011 int res1 = 0 ;
19012 PyObject *swig_obj[1] ;
19013
19014 if (!args) SWIG_fail;
19015 swig_obj[0] = args;
19016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19017 if (!SWIG_IsOK(res1)) {
19018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19019 }
19020 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 resultobj = SWIG_From_long(static_cast< long >(result));
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19037 int arg2 ;
19038 void *argp1 = 0 ;
19039 int res1 = 0 ;
19040 int val2 ;
19041 int ecode2 = 0 ;
19042 PyObject * obj0 = 0 ;
19043 PyObject * obj1 = 0 ;
19044 char * kwnames[] = {
19045 (char *) "self",(char *) "i", NULL
19046 };
19047
19048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19050 if (!SWIG_IsOK(res1)) {
19051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19052 }
19053 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19054 ecode2 = SWIG_AsVal_int(obj1, &val2);
19055 if (!SWIG_IsOK(ecode2)) {
19056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19057 }
19058 arg2 = static_cast< int >(val2);
19059 {
19060 PyThreadState* __tstate = wxPyBeginAllowThreads();
19061 (arg1)->SetInt(arg2);
19062 wxPyEndAllowThreads(__tstate);
19063 if (PyErr_Occurred()) SWIG_fail;
19064 }
19065 resultobj = SWIG_Py_Void();
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19073 PyObject *resultobj = 0;
19074 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19075 int result;
19076 void *argp1 = 0 ;
19077 int res1 = 0 ;
19078 PyObject *swig_obj[1] ;
19079
19080 if (!args) SWIG_fail;
19081 swig_obj[0] = args;
19082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19083 if (!SWIG_IsOK(res1)) {
19084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19085 }
19086 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_From_int(static_cast< int >(result));
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19101 PyObject *resultobj = 0;
19102 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19103 PyObject *result = 0 ;
19104 void *argp1 = 0 ;
19105 int res1 = 0 ;
19106 PyObject *swig_obj[1] ;
19107
19108 if (!args) SWIG_fail;
19109 swig_obj[0] = args;
19110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19111 if (!SWIG_IsOK(res1)) {
19112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19113 }
19114 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = result;
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19129 PyObject *resultobj = 0;
19130 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19131 PyObject *arg2 = (PyObject *) 0 ;
19132 void *argp1 = 0 ;
19133 int res1 = 0 ;
19134 PyObject * obj0 = 0 ;
19135 PyObject * obj1 = 0 ;
19136 char * kwnames[] = {
19137 (char *) "self",(char *) "clientData", NULL
19138 };
19139
19140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19142 if (!SWIG_IsOK(res1)) {
19143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19144 }
19145 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19146 arg2 = obj1;
19147 {
19148 PyThreadState* __tstate = wxPyBeginAllowThreads();
19149 wxCommandEvent_SetClientData(arg1,arg2);
19150 wxPyEndAllowThreads(__tstate);
19151 if (PyErr_Occurred()) SWIG_fail;
19152 }
19153 resultobj = SWIG_Py_Void();
19154 return resultobj;
19155 fail:
19156 return NULL;
19157 }
19158
19159
19160 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19161 PyObject *resultobj = 0;
19162 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19163 wxEvent *result = 0 ;
19164 void *argp1 = 0 ;
19165 int res1 = 0 ;
19166 PyObject *swig_obj[1] ;
19167
19168 if (!args) SWIG_fail;
19169 swig_obj[0] = args;
19170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19171 if (!SWIG_IsOK(res1)) {
19172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19173 }
19174 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19175 {
19176 PyThreadState* __tstate = wxPyBeginAllowThreads();
19177 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19189 PyObject *obj;
19190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19191 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19192 return SWIG_Py_Void();
19193 }
19194
19195 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19196 return SWIG_Python_InitShadowInstance(args);
19197 }
19198
19199 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19200 PyObject *resultobj = 0;
19201 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19202 int arg2 = (int) 0 ;
19203 wxNotifyEvent *result = 0 ;
19204 int val1 ;
19205 int ecode1 = 0 ;
19206 int val2 ;
19207 int ecode2 = 0 ;
19208 PyObject * obj0 = 0 ;
19209 PyObject * obj1 = 0 ;
19210 char * kwnames[] = {
19211 (char *) "commandType",(char *) "winid", NULL
19212 };
19213
19214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19215 if (obj0) {
19216 ecode1 = SWIG_AsVal_int(obj0, &val1);
19217 if (!SWIG_IsOK(ecode1)) {
19218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19219 }
19220 arg1 = static_cast< wxEventType >(val1);
19221 }
19222 if (obj1) {
19223 ecode2 = SWIG_AsVal_int(obj1, &val2);
19224 if (!SWIG_IsOK(ecode2)) {
19225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19226 }
19227 arg2 = static_cast< int >(val2);
19228 }
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19243 PyObject *resultobj = 0;
19244 wxNotifyEvent *arg1 = (wxNotifyEvent *) 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_wxNotifyEvent, 0 | 0 );
19252 if (!SWIG_IsOK(res1)) {
19253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19254 }
19255 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 (arg1)->Veto();
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 resultobj = SWIG_Py_Void();
19263 return resultobj;
19264 fail:
19265 return NULL;
19266 }
19267
19268
19269 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19270 PyObject *resultobj = 0;
19271 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19272 void *argp1 = 0 ;
19273 int res1 = 0 ;
19274 PyObject *swig_obj[1] ;
19275
19276 if (!args) SWIG_fail;
19277 swig_obj[0] = args;
19278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19279 if (!SWIG_IsOK(res1)) {
19280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19281 }
19282 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 (arg1)->Allow();
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 resultobj = SWIG_Py_Void();
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19297 PyObject *resultobj = 0;
19298 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19299 bool result;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19309 }
19310 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (bool)(arg1)->IsAllowed();
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19319 }
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19327 PyObject *obj;
19328 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19329 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19330 return SWIG_Py_Void();
19331 }
19332
19333 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 return SWIG_Python_InitShadowInstance(args);
19335 }
19336
19337 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19338 PyObject *resultobj = 0;
19339 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19340 int arg2 = (int) 0 ;
19341 int arg3 = (int) 0 ;
19342 int arg4 = (int) 0 ;
19343 wxScrollEvent *result = 0 ;
19344 int val1 ;
19345 int ecode1 = 0 ;
19346 int val2 ;
19347 int ecode2 = 0 ;
19348 int val3 ;
19349 int ecode3 = 0 ;
19350 int val4 ;
19351 int ecode4 = 0 ;
19352 PyObject * obj0 = 0 ;
19353 PyObject * obj1 = 0 ;
19354 PyObject * obj2 = 0 ;
19355 PyObject * obj3 = 0 ;
19356 char * kwnames[] = {
19357 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19358 };
19359
19360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19361 if (obj0) {
19362 ecode1 = SWIG_AsVal_int(obj0, &val1);
19363 if (!SWIG_IsOK(ecode1)) {
19364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19365 }
19366 arg1 = static_cast< wxEventType >(val1);
19367 }
19368 if (obj1) {
19369 ecode2 = SWIG_AsVal_int(obj1, &val2);
19370 if (!SWIG_IsOK(ecode2)) {
19371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19372 }
19373 arg2 = static_cast< int >(val2);
19374 }
19375 if (obj2) {
19376 ecode3 = SWIG_AsVal_int(obj2, &val3);
19377 if (!SWIG_IsOK(ecode3)) {
19378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19379 }
19380 arg3 = static_cast< int >(val3);
19381 }
19382 if (obj3) {
19383 ecode4 = SWIG_AsVal_int(obj3, &val4);
19384 if (!SWIG_IsOK(ecode4)) {
19385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19386 }
19387 arg4 = static_cast< int >(val4);
19388 }
19389 {
19390 PyThreadState* __tstate = wxPyBeginAllowThreads();
19391 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19403 PyObject *resultobj = 0;
19404 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19405 int result;
19406 void *argp1 = 0 ;
19407 int res1 = 0 ;
19408 PyObject *swig_obj[1] ;
19409
19410 if (!args) SWIG_fail;
19411 swig_obj[0] = args;
19412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19413 if (!SWIG_IsOK(res1)) {
19414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19415 }
19416 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 resultobj = SWIG_From_int(static_cast< int >(result));
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19431 PyObject *resultobj = 0;
19432 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19433 int result;
19434 void *argp1 = 0 ;
19435 int res1 = 0 ;
19436 PyObject *swig_obj[1] ;
19437
19438 if (!args) SWIG_fail;
19439 swig_obj[0] = args;
19440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19441 if (!SWIG_IsOK(res1)) {
19442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19443 }
19444 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19445 {
19446 PyThreadState* __tstate = wxPyBeginAllowThreads();
19447 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19448 wxPyEndAllowThreads(__tstate);
19449 if (PyErr_Occurred()) SWIG_fail;
19450 }
19451 resultobj = SWIG_From_int(static_cast< int >(result));
19452 return resultobj;
19453 fail:
19454 return NULL;
19455 }
19456
19457
19458 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19459 PyObject *resultobj = 0;
19460 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19461 int arg2 ;
19462 void *argp1 = 0 ;
19463 int res1 = 0 ;
19464 int val2 ;
19465 int ecode2 = 0 ;
19466 PyObject * obj0 = 0 ;
19467 PyObject * obj1 = 0 ;
19468 char * kwnames[] = {
19469 (char *) "self",(char *) "orient", NULL
19470 };
19471
19472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19474 if (!SWIG_IsOK(res1)) {
19475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19476 }
19477 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19478 ecode2 = SWIG_AsVal_int(obj1, &val2);
19479 if (!SWIG_IsOK(ecode2)) {
19480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19481 }
19482 arg2 = static_cast< int >(val2);
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 (arg1)->SetOrientation(arg2);
19486 wxPyEndAllowThreads(__tstate);
19487 if (PyErr_Occurred()) SWIG_fail;
19488 }
19489 resultobj = SWIG_Py_Void();
19490 return resultobj;
19491 fail:
19492 return NULL;
19493 }
19494
19495
19496 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19497 PyObject *resultobj = 0;
19498 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19499 int arg2 ;
19500 void *argp1 = 0 ;
19501 int res1 = 0 ;
19502 int val2 ;
19503 int ecode2 = 0 ;
19504 PyObject * obj0 = 0 ;
19505 PyObject * obj1 = 0 ;
19506 char * kwnames[] = {
19507 (char *) "self",(char *) "pos", NULL
19508 };
19509
19510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19512 if (!SWIG_IsOK(res1)) {
19513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19514 }
19515 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19516 ecode2 = SWIG_AsVal_int(obj1, &val2);
19517 if (!SWIG_IsOK(ecode2)) {
19518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19519 }
19520 arg2 = static_cast< int >(val2);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 (arg1)->SetPosition(arg2);
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_Py_Void();
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19535 PyObject *obj;
19536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19537 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19538 return SWIG_Py_Void();
19539 }
19540
19541 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19542 return SWIG_Python_InitShadowInstance(args);
19543 }
19544
19545 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19546 PyObject *resultobj = 0;
19547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19548 int arg2 = (int) 0 ;
19549 int arg3 = (int) 0 ;
19550 wxScrollWinEvent *result = 0 ;
19551 int val1 ;
19552 int ecode1 = 0 ;
19553 int val2 ;
19554 int ecode2 = 0 ;
19555 int val3 ;
19556 int ecode3 = 0 ;
19557 PyObject * obj0 = 0 ;
19558 PyObject * obj1 = 0 ;
19559 PyObject * obj2 = 0 ;
19560 char * kwnames[] = {
19561 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19562 };
19563
19564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19565 if (obj0) {
19566 ecode1 = SWIG_AsVal_int(obj0, &val1);
19567 if (!SWIG_IsOK(ecode1)) {
19568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19569 }
19570 arg1 = static_cast< wxEventType >(val1);
19571 }
19572 if (obj1) {
19573 ecode2 = SWIG_AsVal_int(obj1, &val2);
19574 if (!SWIG_IsOK(ecode2)) {
19575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19576 }
19577 arg2 = static_cast< int >(val2);
19578 }
19579 if (obj2) {
19580 ecode3 = SWIG_AsVal_int(obj2, &val3);
19581 if (!SWIG_IsOK(ecode3)) {
19582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19583 }
19584 arg3 = static_cast< int >(val3);
19585 }
19586 {
19587 PyThreadState* __tstate = wxPyBeginAllowThreads();
19588 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19589 wxPyEndAllowThreads(__tstate);
19590 if (PyErr_Occurred()) SWIG_fail;
19591 }
19592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19600 PyObject *resultobj = 0;
19601 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19602 int result;
19603 void *argp1 = 0 ;
19604 int res1 = 0 ;
19605 PyObject *swig_obj[1] ;
19606
19607 if (!args) SWIG_fail;
19608 swig_obj[0] = args;
19609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19610 if (!SWIG_IsOK(res1)) {
19611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19612 }
19613 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19614 {
19615 PyThreadState* __tstate = wxPyBeginAllowThreads();
19616 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19617 wxPyEndAllowThreads(__tstate);
19618 if (PyErr_Occurred()) SWIG_fail;
19619 }
19620 resultobj = SWIG_From_int(static_cast< int >(result));
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19628 PyObject *resultobj = 0;
19629 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19630 int result;
19631 void *argp1 = 0 ;
19632 int res1 = 0 ;
19633 PyObject *swig_obj[1] ;
19634
19635 if (!args) SWIG_fail;
19636 swig_obj[0] = args;
19637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19638 if (!SWIG_IsOK(res1)) {
19639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19640 }
19641 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19642 {
19643 PyThreadState* __tstate = wxPyBeginAllowThreads();
19644 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19645 wxPyEndAllowThreads(__tstate);
19646 if (PyErr_Occurred()) SWIG_fail;
19647 }
19648 resultobj = SWIG_From_int(static_cast< int >(result));
19649 return resultobj;
19650 fail:
19651 return NULL;
19652 }
19653
19654
19655 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19656 PyObject *resultobj = 0;
19657 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19658 int arg2 ;
19659 void *argp1 = 0 ;
19660 int res1 = 0 ;
19661 int val2 ;
19662 int ecode2 = 0 ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 char * kwnames[] = {
19666 (char *) "self",(char *) "orient", NULL
19667 };
19668
19669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19671 if (!SWIG_IsOK(res1)) {
19672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19673 }
19674 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19675 ecode2 = SWIG_AsVal_int(obj1, &val2);
19676 if (!SWIG_IsOK(ecode2)) {
19677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19678 }
19679 arg2 = static_cast< int >(val2);
19680 {
19681 PyThreadState* __tstate = wxPyBeginAllowThreads();
19682 (arg1)->SetOrientation(arg2);
19683 wxPyEndAllowThreads(__tstate);
19684 if (PyErr_Occurred()) SWIG_fail;
19685 }
19686 resultobj = SWIG_Py_Void();
19687 return resultobj;
19688 fail:
19689 return NULL;
19690 }
19691
19692
19693 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19694 PyObject *resultobj = 0;
19695 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19696 int arg2 ;
19697 void *argp1 = 0 ;
19698 int res1 = 0 ;
19699 int val2 ;
19700 int ecode2 = 0 ;
19701 PyObject * obj0 = 0 ;
19702 PyObject * obj1 = 0 ;
19703 char * kwnames[] = {
19704 (char *) "self",(char *) "pos", NULL
19705 };
19706
19707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19711 }
19712 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19713 ecode2 = SWIG_AsVal_int(obj1, &val2);
19714 if (!SWIG_IsOK(ecode2)) {
19715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19716 }
19717 arg2 = static_cast< int >(val2);
19718 {
19719 PyThreadState* __tstate = wxPyBeginAllowThreads();
19720 (arg1)->SetPosition(arg2);
19721 wxPyEndAllowThreads(__tstate);
19722 if (PyErr_Occurred()) SWIG_fail;
19723 }
19724 resultobj = SWIG_Py_Void();
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19732 PyObject *obj;
19733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19734 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19735 return SWIG_Py_Void();
19736 }
19737
19738 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19739 return SWIG_Python_InitShadowInstance(args);
19740 }
19741
19742 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19743 PyObject *resultobj = 0;
19744 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19745 wxMouseEvent *result = 0 ;
19746 int val1 ;
19747 int ecode1 = 0 ;
19748 PyObject * obj0 = 0 ;
19749 char * kwnames[] = {
19750 (char *) "mouseType", NULL
19751 };
19752
19753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19754 if (obj0) {
19755 ecode1 = SWIG_AsVal_int(obj0, &val1);
19756 if (!SWIG_IsOK(ecode1)) {
19757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19758 }
19759 arg1 = static_cast< wxEventType >(val1);
19760 }
19761 {
19762 PyThreadState* __tstate = wxPyBeginAllowThreads();
19763 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19764 wxPyEndAllowThreads(__tstate);
19765 if (PyErr_Occurred()) SWIG_fail;
19766 }
19767 {
19768 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19769 }
19770 return resultobj;
19771 fail:
19772 return NULL;
19773 }
19774
19775
19776 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19777 PyObject *resultobj = 0;
19778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19779 bool result;
19780 void *argp1 = 0 ;
19781 int res1 = 0 ;
19782 PyObject *swig_obj[1] ;
19783
19784 if (!args) SWIG_fail;
19785 swig_obj[0] = args;
19786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19787 if (!SWIG_IsOK(res1)) {
19788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19789 }
19790 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19791 {
19792 PyThreadState* __tstate = wxPyBeginAllowThreads();
19793 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19794 wxPyEndAllowThreads(__tstate);
19795 if (PyErr_Occurred()) SWIG_fail;
19796 }
19797 {
19798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19799 }
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = 0;
19808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19809 int arg2 = (int) wxMOUSE_BTN_ANY ;
19810 bool result;
19811 void *argp1 = 0 ;
19812 int res1 = 0 ;
19813 int val2 ;
19814 int ecode2 = 0 ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char * kwnames[] = {
19818 (char *) "self",(char *) "but", NULL
19819 };
19820
19821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19823 if (!SWIG_IsOK(res1)) {
19824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19825 }
19826 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19827 if (obj1) {
19828 ecode2 = SWIG_AsVal_int(obj1, &val2);
19829 if (!SWIG_IsOK(ecode2)) {
19830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19831 }
19832 arg2 = static_cast< int >(val2);
19833 }
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 {
19841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19842 }
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj = 0;
19851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19852 int arg2 = (int) wxMOUSE_BTN_ANY ;
19853 bool result;
19854 void *argp1 = 0 ;
19855 int res1 = 0 ;
19856 int val2 ;
19857 int ecode2 = 0 ;
19858 PyObject * obj0 = 0 ;
19859 PyObject * obj1 = 0 ;
19860 char * kwnames[] = {
19861 (char *) "self",(char *) "but", NULL
19862 };
19863
19864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19866 if (!SWIG_IsOK(res1)) {
19867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19868 }
19869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19870 if (obj1) {
19871 ecode2 = SWIG_AsVal_int(obj1, &val2);
19872 if (!SWIG_IsOK(ecode2)) {
19873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19874 }
19875 arg2 = static_cast< int >(val2);
19876 }
19877 {
19878 PyThreadState* __tstate = wxPyBeginAllowThreads();
19879 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19880 wxPyEndAllowThreads(__tstate);
19881 if (PyErr_Occurred()) SWIG_fail;
19882 }
19883 {
19884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19885 }
19886 return resultobj;
19887 fail:
19888 return NULL;
19889 }
19890
19891
19892 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19893 PyObject *resultobj = 0;
19894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19895 int arg2 = (int) wxMOUSE_BTN_ANY ;
19896 bool result;
19897 void *argp1 = 0 ;
19898 int res1 = 0 ;
19899 int val2 ;
19900 int ecode2 = 0 ;
19901 PyObject * obj0 = 0 ;
19902 PyObject * obj1 = 0 ;
19903 char * kwnames[] = {
19904 (char *) "self",(char *) "but", NULL
19905 };
19906
19907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19909 if (!SWIG_IsOK(res1)) {
19910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19911 }
19912 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19913 if (obj1) {
19914 ecode2 = SWIG_AsVal_int(obj1, &val2);
19915 if (!SWIG_IsOK(ecode2)) {
19916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19917 }
19918 arg2 = static_cast< int >(val2);
19919 }
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 {
19927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19928 }
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = 0;
19937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19938 int arg2 ;
19939 bool result;
19940 void *argp1 = 0 ;
19941 int res1 = 0 ;
19942 int val2 ;
19943 int ecode2 = 0 ;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 char * kwnames[] = {
19947 (char *) "self",(char *) "button", NULL
19948 };
19949
19950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 ecode2 = SWIG_AsVal_int(obj1, &val2);
19957 if (!SWIG_IsOK(ecode2)) {
19958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19959 }
19960 arg2 = static_cast< int >(val2);
19961 {
19962 PyThreadState* __tstate = wxPyBeginAllowThreads();
19963 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19964 wxPyEndAllowThreads(__tstate);
19965 if (PyErr_Occurred()) SWIG_fail;
19966 }
19967 {
19968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19969 }
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj = 0;
19978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19979 int arg2 ;
19980 bool result;
19981 void *argp1 = 0 ;
19982 int res1 = 0 ;
19983 int val2 ;
19984 int ecode2 = 0 ;
19985 PyObject * obj0 = 0 ;
19986 PyObject * obj1 = 0 ;
19987 char * kwnames[] = {
19988 (char *) "self",(char *) "but", NULL
19989 };
19990
19991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19993 if (!SWIG_IsOK(res1)) {
19994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19995 }
19996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19997 ecode2 = SWIG_AsVal_int(obj1, &val2);
19998 if (!SWIG_IsOK(ecode2)) {
19999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20000 }
20001 arg2 = static_cast< int >(val2);
20002 {
20003 PyThreadState* __tstate = wxPyBeginAllowThreads();
20004 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20005 wxPyEndAllowThreads(__tstate);
20006 if (PyErr_Occurred()) SWIG_fail;
20007 }
20008 {
20009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20018 PyObject *resultobj = 0;
20019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20020 int result;
20021 void *argp1 = 0 ;
20022 int res1 = 0 ;
20023 PyObject *swig_obj[1] ;
20024
20025 if (!args) SWIG_fail;
20026 swig_obj[0] = args;
20027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20028 if (!SWIG_IsOK(res1)) {
20029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20030 }
20031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20032 {
20033 PyThreadState* __tstate = wxPyBeginAllowThreads();
20034 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20035 wxPyEndAllowThreads(__tstate);
20036 if (PyErr_Occurred()) SWIG_fail;
20037 }
20038 resultobj = SWIG_From_int(static_cast< int >(result));
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20046 PyObject *resultobj = 0;
20047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20048 bool result;
20049 void *argp1 = 0 ;
20050 int res1 = 0 ;
20051 PyObject *swig_obj[1] ;
20052
20053 if (!args) SWIG_fail;
20054 swig_obj[0] = args;
20055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20056 if (!SWIG_IsOK(res1)) {
20057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20058 }
20059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 {
20067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20068 }
20069 return resultobj;
20070 fail:
20071 return NULL;
20072 }
20073
20074
20075 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20076 PyObject *resultobj = 0;
20077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20078 bool result;
20079 void *argp1 = 0 ;
20080 int res1 = 0 ;
20081 PyObject *swig_obj[1] ;
20082
20083 if (!args) SWIG_fail;
20084 swig_obj[0] = args;
20085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20086 if (!SWIG_IsOK(res1)) {
20087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20088 }
20089 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 {
20097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20098 }
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20106 PyObject *resultobj = 0;
20107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20108 bool result;
20109 void *argp1 = 0 ;
20110 int res1 = 0 ;
20111 PyObject *swig_obj[1] ;
20112
20113 if (!args) SWIG_fail;
20114 swig_obj[0] = args;
20115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20116 if (!SWIG_IsOK(res1)) {
20117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20118 }
20119 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20120 {
20121 PyThreadState* __tstate = wxPyBeginAllowThreads();
20122 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20123 wxPyEndAllowThreads(__tstate);
20124 if (PyErr_Occurred()) SWIG_fail;
20125 }
20126 {
20127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20128 }
20129 return resultobj;
20130 fail:
20131 return NULL;
20132 }
20133
20134
20135 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20136 PyObject *resultobj = 0;
20137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20138 bool result;
20139 void *argp1 = 0 ;
20140 int res1 = 0 ;
20141 PyObject *swig_obj[1] ;
20142
20143 if (!args) SWIG_fail;
20144 swig_obj[0] = args;
20145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20146 if (!SWIG_IsOK(res1)) {
20147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20148 }
20149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 {
20157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20158 }
20159 return resultobj;
20160 fail:
20161 return NULL;
20162 }
20163
20164
20165 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20166 PyObject *resultobj = 0;
20167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20168 bool result;
20169 void *argp1 = 0 ;
20170 int res1 = 0 ;
20171 PyObject *swig_obj[1] ;
20172
20173 if (!args) SWIG_fail;
20174 swig_obj[0] = args;
20175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20176 if (!SWIG_IsOK(res1)) {
20177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20178 }
20179 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 {
20187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20188 }
20189 return resultobj;
20190 fail:
20191 return NULL;
20192 }
20193
20194
20195 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20196 PyObject *resultobj = 0;
20197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20198 bool result;
20199 void *argp1 = 0 ;
20200 int res1 = 0 ;
20201 PyObject *swig_obj[1] ;
20202
20203 if (!args) SWIG_fail;
20204 swig_obj[0] = args;
20205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20206 if (!SWIG_IsOK(res1)) {
20207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20208 }
20209 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20210 {
20211 PyThreadState* __tstate = wxPyBeginAllowThreads();
20212 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20213 wxPyEndAllowThreads(__tstate);
20214 if (PyErr_Occurred()) SWIG_fail;
20215 }
20216 {
20217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20218 }
20219 return resultobj;
20220 fail:
20221 return NULL;
20222 }
20223
20224
20225 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 PyObject *resultobj = 0;
20227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20228 bool result;
20229 void *argp1 = 0 ;
20230 int res1 = 0 ;
20231 PyObject *swig_obj[1] ;
20232
20233 if (!args) SWIG_fail;
20234 swig_obj[0] = args;
20235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20236 if (!SWIG_IsOK(res1)) {
20237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20238 }
20239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20240 {
20241 PyThreadState* __tstate = wxPyBeginAllowThreads();
20242 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20243 wxPyEndAllowThreads(__tstate);
20244 if (PyErr_Occurred()) SWIG_fail;
20245 }
20246 {
20247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20248 }
20249 return resultobj;
20250 fail:
20251 return NULL;
20252 }
20253
20254
20255 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20256 PyObject *resultobj = 0;
20257 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20258 bool result;
20259 void *argp1 = 0 ;
20260 int res1 = 0 ;
20261 PyObject *swig_obj[1] ;
20262
20263 if (!args) SWIG_fail;
20264 swig_obj[0] = args;
20265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20266 if (!SWIG_IsOK(res1)) {
20267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20268 }
20269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20270 {
20271 PyThreadState* __tstate = wxPyBeginAllowThreads();
20272 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20273 wxPyEndAllowThreads(__tstate);
20274 if (PyErr_Occurred()) SWIG_fail;
20275 }
20276 {
20277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20278 }
20279 return resultobj;
20280 fail:
20281 return NULL;
20282 }
20283
20284
20285 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20286 PyObject *resultobj = 0;
20287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20288 bool result;
20289 void *argp1 = 0 ;
20290 int res1 = 0 ;
20291 PyObject *swig_obj[1] ;
20292
20293 if (!args) SWIG_fail;
20294 swig_obj[0] = args;
20295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20296 if (!SWIG_IsOK(res1)) {
20297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20298 }
20299 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 {
20307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20308 }
20309 return resultobj;
20310 fail:
20311 return NULL;
20312 }
20313
20314
20315 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *resultobj = 0;
20317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20318 bool result;
20319 void *argp1 = 0 ;
20320 int res1 = 0 ;
20321 PyObject *swig_obj[1] ;
20322
20323 if (!args) SWIG_fail;
20324 swig_obj[0] = args;
20325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20326 if (!SWIG_IsOK(res1)) {
20327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20328 }
20329 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 {
20337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20338 }
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20348 bool result;
20349 void *argp1 = 0 ;
20350 int res1 = 0 ;
20351 PyObject *swig_obj[1] ;
20352
20353 if (!args) SWIG_fail;
20354 swig_obj[0] = args;
20355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20356 if (!SWIG_IsOK(res1)) {
20357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20358 }
20359 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20360 {
20361 PyThreadState* __tstate = wxPyBeginAllowThreads();
20362 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20363 wxPyEndAllowThreads(__tstate);
20364 if (PyErr_Occurred()) SWIG_fail;
20365 }
20366 {
20367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20368 }
20369 return resultobj;
20370 fail:
20371 return NULL;
20372 }
20373
20374
20375 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20376 PyObject *resultobj = 0;
20377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20378 bool result;
20379 void *argp1 = 0 ;
20380 int res1 = 0 ;
20381 PyObject *swig_obj[1] ;
20382
20383 if (!args) SWIG_fail;
20384 swig_obj[0] = args;
20385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20386 if (!SWIG_IsOK(res1)) {
20387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20388 }
20389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20390 {
20391 PyThreadState* __tstate = wxPyBeginAllowThreads();
20392 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20393 wxPyEndAllowThreads(__tstate);
20394 if (PyErr_Occurred()) SWIG_fail;
20395 }
20396 {
20397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20398 }
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20406 PyObject *resultobj = 0;
20407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20408 bool result;
20409 void *argp1 = 0 ;
20410 int res1 = 0 ;
20411 PyObject *swig_obj[1] ;
20412
20413 if (!args) SWIG_fail;
20414 swig_obj[0] = args;
20415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20416 if (!SWIG_IsOK(res1)) {
20417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20418 }
20419 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20420 {
20421 PyThreadState* __tstate = wxPyBeginAllowThreads();
20422 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20423 wxPyEndAllowThreads(__tstate);
20424 if (PyErr_Occurred()) SWIG_fail;
20425 }
20426 {
20427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20428 }
20429 return resultobj;
20430 fail:
20431 return NULL;
20432 }
20433
20434
20435 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20436 PyObject *resultobj = 0;
20437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20438 bool result;
20439 void *argp1 = 0 ;
20440 int res1 = 0 ;
20441 PyObject *swig_obj[1] ;
20442
20443 if (!args) SWIG_fail;
20444 swig_obj[0] = args;
20445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20446 if (!SWIG_IsOK(res1)) {
20447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20448 }
20449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 {
20457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20458 }
20459 return resultobj;
20460 fail:
20461 return NULL;
20462 }
20463
20464
20465 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20466 PyObject *resultobj = 0;
20467 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20468 bool result;
20469 void *argp1 = 0 ;
20470 int res1 = 0 ;
20471 PyObject *swig_obj[1] ;
20472
20473 if (!args) SWIG_fail;
20474 swig_obj[0] = args;
20475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20476 if (!SWIG_IsOK(res1)) {
20477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20478 }
20479 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20480 {
20481 PyThreadState* __tstate = wxPyBeginAllowThreads();
20482 result = (bool)(arg1)->LeftIsDown();
20483 wxPyEndAllowThreads(__tstate);
20484 if (PyErr_Occurred()) SWIG_fail;
20485 }
20486 {
20487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20488 }
20489 return resultobj;
20490 fail:
20491 return NULL;
20492 }
20493
20494
20495 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20496 PyObject *resultobj = 0;
20497 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20498 bool result;
20499 void *argp1 = 0 ;
20500 int res1 = 0 ;
20501 PyObject *swig_obj[1] ;
20502
20503 if (!args) SWIG_fail;
20504 swig_obj[0] = args;
20505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20506 if (!SWIG_IsOK(res1)) {
20507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20508 }
20509 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20510 {
20511 PyThreadState* __tstate = wxPyBeginAllowThreads();
20512 result = (bool)(arg1)->MiddleIsDown();
20513 wxPyEndAllowThreads(__tstate);
20514 if (PyErr_Occurred()) SWIG_fail;
20515 }
20516 {
20517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20518 }
20519 return resultobj;
20520 fail:
20521 return NULL;
20522 }
20523
20524
20525 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20526 PyObject *resultobj = 0;
20527 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20528 bool result;
20529 void *argp1 = 0 ;
20530 int res1 = 0 ;
20531 PyObject *swig_obj[1] ;
20532
20533 if (!args) SWIG_fail;
20534 swig_obj[0] = args;
20535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20536 if (!SWIG_IsOK(res1)) {
20537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20538 }
20539 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 result = (bool)(arg1)->RightIsDown();
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 {
20547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20548 }
20549 return resultobj;
20550 fail:
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20556 PyObject *resultobj = 0;
20557 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20558 bool result;
20559 void *argp1 = 0 ;
20560 int res1 = 0 ;
20561 PyObject *swig_obj[1] ;
20562
20563 if (!args) SWIG_fail;
20564 swig_obj[0] = args;
20565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20568 }
20569 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 {
20577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20586 PyObject *resultobj = 0;
20587 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20588 bool result;
20589 void *argp1 = 0 ;
20590 int res1 = 0 ;
20591 PyObject *swig_obj[1] ;
20592
20593 if (!args) SWIG_fail;
20594 swig_obj[0] = args;
20595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20596 if (!SWIG_IsOK(res1)) {
20597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20598 }
20599 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 {
20607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20616 PyObject *resultobj = 0;
20617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20618 bool result;
20619 void *argp1 = 0 ;
20620 int res1 = 0 ;
20621 PyObject *swig_obj[1] ;
20622
20623 if (!args) SWIG_fail;
20624 swig_obj[0] = args;
20625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20626 if (!SWIG_IsOK(res1)) {
20627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20628 }
20629 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20630 {
20631 PyThreadState* __tstate = wxPyBeginAllowThreads();
20632 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20633 wxPyEndAllowThreads(__tstate);
20634 if (PyErr_Occurred()) SWIG_fail;
20635 }
20636 {
20637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20638 }
20639 return resultobj;
20640 fail:
20641 return NULL;
20642 }
20643
20644
20645 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20646 PyObject *resultobj = 0;
20647 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20648 bool result;
20649 void *argp1 = 0 ;
20650 int res1 = 0 ;
20651 PyObject *swig_obj[1] ;
20652
20653 if (!args) SWIG_fail;
20654 swig_obj[0] = args;
20655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20656 if (!SWIG_IsOK(res1)) {
20657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20658 }
20659 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20660 {
20661 PyThreadState* __tstate = wxPyBeginAllowThreads();
20662 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20663 wxPyEndAllowThreads(__tstate);
20664 if (PyErr_Occurred()) SWIG_fail;
20665 }
20666 {
20667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20668 }
20669 return resultobj;
20670 fail:
20671 return NULL;
20672 }
20673
20674
20675 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20676 PyObject *resultobj = 0;
20677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20678 wxPoint result;
20679 void *argp1 = 0 ;
20680 int res1 = 0 ;
20681 PyObject *swig_obj[1] ;
20682
20683 if (!args) SWIG_fail;
20684 swig_obj[0] = args;
20685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20686 if (!SWIG_IsOK(res1)) {
20687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20688 }
20689 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20690 {
20691 PyThreadState* __tstate = wxPyBeginAllowThreads();
20692 result = (arg1)->GetPosition();
20693 wxPyEndAllowThreads(__tstate);
20694 if (PyErr_Occurred()) SWIG_fail;
20695 }
20696 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20704 PyObject *resultobj = 0;
20705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20706 long *arg2 = (long *) 0 ;
20707 long *arg3 = (long *) 0 ;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 long temp2 ;
20711 int res2 = SWIG_TMPOBJ ;
20712 long temp3 ;
20713 int res3 = SWIG_TMPOBJ ;
20714 PyObject *swig_obj[1] ;
20715
20716 arg2 = &temp2;
20717 arg3 = &temp3;
20718 if (!args) SWIG_fail;
20719 swig_obj[0] = args;
20720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20721 if (!SWIG_IsOK(res1)) {
20722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20723 }
20724 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20725 {
20726 PyThreadState* __tstate = wxPyBeginAllowThreads();
20727 (arg1)->GetPosition(arg2,arg3);
20728 wxPyEndAllowThreads(__tstate);
20729 if (PyErr_Occurred()) SWIG_fail;
20730 }
20731 resultobj = SWIG_Py_Void();
20732 if (SWIG_IsTmpObj(res2)) {
20733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20734 } else {
20735 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20737 }
20738 if (SWIG_IsTmpObj(res3)) {
20739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20740 } else {
20741 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20743 }
20744 return resultobj;
20745 fail:
20746 return NULL;
20747 }
20748
20749
20750 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20751 PyObject *resultobj = 0;
20752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20753 wxDC *arg2 = 0 ;
20754 wxPoint result;
20755 void *argp1 = 0 ;
20756 int res1 = 0 ;
20757 void *argp2 = 0 ;
20758 int res2 = 0 ;
20759 PyObject * obj0 = 0 ;
20760 PyObject * obj1 = 0 ;
20761 char * kwnames[] = {
20762 (char *) "self",(char *) "dc", NULL
20763 };
20764
20765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20767 if (!SWIG_IsOK(res1)) {
20768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20769 }
20770 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20772 if (!SWIG_IsOK(res2)) {
20773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20774 }
20775 if (!argp2) {
20776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20777 }
20778 arg2 = reinterpret_cast< wxDC * >(argp2);
20779 {
20780 PyThreadState* __tstate = wxPyBeginAllowThreads();
20781 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20793 PyObject *resultobj = 0;
20794 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20795 int result;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 PyObject *swig_obj[1] ;
20799
20800 if (!args) SWIG_fail;
20801 swig_obj[0] = args;
20802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20803 if (!SWIG_IsOK(res1)) {
20804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20805 }
20806 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20807 {
20808 PyThreadState* __tstate = wxPyBeginAllowThreads();
20809 result = (int)((wxMouseEvent const *)arg1)->GetX();
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 resultobj = SWIG_From_int(static_cast< int >(result));
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 PyObject *resultobj = 0;
20822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20823 int result;
20824 void *argp1 = 0 ;
20825 int res1 = 0 ;
20826 PyObject *swig_obj[1] ;
20827
20828 if (!args) SWIG_fail;
20829 swig_obj[0] = args;
20830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20831 if (!SWIG_IsOK(res1)) {
20832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20833 }
20834 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20835 {
20836 PyThreadState* __tstate = wxPyBeginAllowThreads();
20837 result = (int)((wxMouseEvent const *)arg1)->GetY();
20838 wxPyEndAllowThreads(__tstate);
20839 if (PyErr_Occurred()) SWIG_fail;
20840 }
20841 resultobj = SWIG_From_int(static_cast< int >(result));
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20849 PyObject *resultobj = 0;
20850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20851 int result;
20852 void *argp1 = 0 ;
20853 int res1 = 0 ;
20854 PyObject *swig_obj[1] ;
20855
20856 if (!args) SWIG_fail;
20857 swig_obj[0] = args;
20858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20859 if (!SWIG_IsOK(res1)) {
20860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20861 }
20862 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20863 {
20864 PyThreadState* __tstate = wxPyBeginAllowThreads();
20865 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 resultobj = SWIG_From_int(static_cast< int >(result));
20870 return resultobj;
20871 fail:
20872 return NULL;
20873 }
20874
20875
20876 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20877 PyObject *resultobj = 0;
20878 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20879 int result;
20880 void *argp1 = 0 ;
20881 int res1 = 0 ;
20882 PyObject *swig_obj[1] ;
20883
20884 if (!args) SWIG_fail;
20885 swig_obj[0] = args;
20886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20887 if (!SWIG_IsOK(res1)) {
20888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20889 }
20890 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20891 {
20892 PyThreadState* __tstate = wxPyBeginAllowThreads();
20893 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20894 wxPyEndAllowThreads(__tstate);
20895 if (PyErr_Occurred()) SWIG_fail;
20896 }
20897 resultobj = SWIG_From_int(static_cast< int >(result));
20898 return resultobj;
20899 fail:
20900 return NULL;
20901 }
20902
20903
20904 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20905 PyObject *resultobj = 0;
20906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20907 int result;
20908 void *argp1 = 0 ;
20909 int res1 = 0 ;
20910 PyObject *swig_obj[1] ;
20911
20912 if (!args) SWIG_fail;
20913 swig_obj[0] = args;
20914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20915 if (!SWIG_IsOK(res1)) {
20916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20917 }
20918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20919 {
20920 PyThreadState* __tstate = wxPyBeginAllowThreads();
20921 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20922 wxPyEndAllowThreads(__tstate);
20923 if (PyErr_Occurred()) SWIG_fail;
20924 }
20925 resultobj = SWIG_From_int(static_cast< int >(result));
20926 return resultobj;
20927 fail:
20928 return NULL;
20929 }
20930
20931
20932 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20933 PyObject *resultobj = 0;
20934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20935 bool result;
20936 void *argp1 = 0 ;
20937 int res1 = 0 ;
20938 PyObject *swig_obj[1] ;
20939
20940 if (!args) SWIG_fail;
20941 swig_obj[0] = args;
20942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20943 if (!SWIG_IsOK(res1)) {
20944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20945 }
20946 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20950 wxPyEndAllowThreads(__tstate);
20951 if (PyErr_Occurred()) SWIG_fail;
20952 }
20953 {
20954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20955 }
20956 return resultobj;
20957 fail:
20958 return NULL;
20959 }
20960
20961
20962 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20963 PyObject *resultobj = 0;
20964 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20965 int arg2 ;
20966 void *argp1 = 0 ;
20967 int res1 = 0 ;
20968 int val2 ;
20969 int ecode2 = 0 ;
20970 PyObject *swig_obj[2] ;
20971
20972 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20974 if (!SWIG_IsOK(res1)) {
20975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20976 }
20977 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20978 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20979 if (!SWIG_IsOK(ecode2)) {
20980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20981 }
20982 arg2 = static_cast< int >(val2);
20983 if (arg1) (arg1)->m_x = arg2;
20984
20985 resultobj = SWIG_Py_Void();
20986 return resultobj;
20987 fail:
20988 return NULL;
20989 }
20990
20991
20992 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20993 PyObject *resultobj = 0;
20994 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20995 int result;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 PyObject *swig_obj[1] ;
20999
21000 if (!args) SWIG_fail;
21001 swig_obj[0] = args;
21002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21003 if (!SWIG_IsOK(res1)) {
21004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21005 }
21006 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21007 result = (int) ((arg1)->m_x);
21008 resultobj = SWIG_From_int(static_cast< int >(result));
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21016 PyObject *resultobj = 0;
21017 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21018 int arg2 ;
21019 void *argp1 = 0 ;
21020 int res1 = 0 ;
21021 int val2 ;
21022 int ecode2 = 0 ;
21023 PyObject *swig_obj[2] ;
21024
21025 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21027 if (!SWIG_IsOK(res1)) {
21028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21029 }
21030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21031 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21032 if (!SWIG_IsOK(ecode2)) {
21033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21034 }
21035 arg2 = static_cast< int >(val2);
21036 if (arg1) (arg1)->m_y = arg2;
21037
21038 resultobj = SWIG_Py_Void();
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21048 int result;
21049 void *argp1 = 0 ;
21050 int res1 = 0 ;
21051 PyObject *swig_obj[1] ;
21052
21053 if (!args) SWIG_fail;
21054 swig_obj[0] = args;
21055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21056 if (!SWIG_IsOK(res1)) {
21057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21058 }
21059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21060 result = (int) ((arg1)->m_y);
21061 resultobj = SWIG_From_int(static_cast< int >(result));
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21069 PyObject *resultobj = 0;
21070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21071 bool arg2 ;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 bool val2 ;
21075 int ecode2 = 0 ;
21076 PyObject *swig_obj[2] ;
21077
21078 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21080 if (!SWIG_IsOK(res1)) {
21081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21082 }
21083 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21084 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21085 if (!SWIG_IsOK(ecode2)) {
21086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21087 }
21088 arg2 = static_cast< bool >(val2);
21089 if (arg1) (arg1)->m_leftDown = arg2;
21090
21091 resultobj = SWIG_Py_Void();
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21099 PyObject *resultobj = 0;
21100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21101 bool result;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 PyObject *swig_obj[1] ;
21105
21106 if (!args) SWIG_fail;
21107 swig_obj[0] = args;
21108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21111 }
21112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21113 result = (bool) ((arg1)->m_leftDown);
21114 {
21115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21116 }
21117 return resultobj;
21118 fail:
21119 return NULL;
21120 }
21121
21122
21123 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21124 PyObject *resultobj = 0;
21125 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21126 bool arg2 ;
21127 void *argp1 = 0 ;
21128 int res1 = 0 ;
21129 bool val2 ;
21130 int ecode2 = 0 ;
21131 PyObject *swig_obj[2] ;
21132
21133 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21135 if (!SWIG_IsOK(res1)) {
21136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21137 }
21138 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21139 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21140 if (!SWIG_IsOK(ecode2)) {
21141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21142 }
21143 arg2 = static_cast< bool >(val2);
21144 if (arg1) (arg1)->m_middleDown = arg2;
21145
21146 resultobj = SWIG_Py_Void();
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21154 PyObject *resultobj = 0;
21155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21156 bool result;
21157 void *argp1 = 0 ;
21158 int res1 = 0 ;
21159 PyObject *swig_obj[1] ;
21160
21161 if (!args) SWIG_fail;
21162 swig_obj[0] = args;
21163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21164 if (!SWIG_IsOK(res1)) {
21165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21166 }
21167 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21168 result = (bool) ((arg1)->m_middleDown);
21169 {
21170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21171 }
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21179 PyObject *resultobj = 0;
21180 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21181 bool arg2 ;
21182 void *argp1 = 0 ;
21183 int res1 = 0 ;
21184 bool val2 ;
21185 int ecode2 = 0 ;
21186 PyObject *swig_obj[2] ;
21187
21188 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
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_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21192 }
21193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21194 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21195 if (!SWIG_IsOK(ecode2)) {
21196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21197 }
21198 arg2 = static_cast< bool >(val2);
21199 if (arg1) (arg1)->m_rightDown = arg2;
21200
21201 resultobj = SWIG_Py_Void();
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *resultobj = 0;
21210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21211 bool result;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 PyObject *swig_obj[1] ;
21215
21216 if (!args) SWIG_fail;
21217 swig_obj[0] = args;
21218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21221 }
21222 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21223 result = (bool) ((arg1)->m_rightDown);
21224 {
21225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21226 }
21227 return resultobj;
21228 fail:
21229 return NULL;
21230 }
21231
21232
21233 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21234 PyObject *resultobj = 0;
21235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21236 bool arg2 ;
21237 void *argp1 = 0 ;
21238 int res1 = 0 ;
21239 bool val2 ;
21240 int ecode2 = 0 ;
21241 PyObject *swig_obj[2] ;
21242
21243 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
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_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21247 }
21248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21249 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21250 if (!SWIG_IsOK(ecode2)) {
21251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21252 }
21253 arg2 = static_cast< bool >(val2);
21254 if (arg1) (arg1)->m_controlDown = arg2;
21255
21256 resultobj = SWIG_Py_Void();
21257 return resultobj;
21258 fail:
21259 return NULL;
21260 }
21261
21262
21263 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21264 PyObject *resultobj = 0;
21265 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21266 bool result;
21267 void *argp1 = 0 ;
21268 int res1 = 0 ;
21269 PyObject *swig_obj[1] ;
21270
21271 if (!args) SWIG_fail;
21272 swig_obj[0] = args;
21273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21274 if (!SWIG_IsOK(res1)) {
21275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21276 }
21277 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21278 result = (bool) ((arg1)->m_controlDown);
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 bool arg2 ;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 bool val2 ;
21295 int ecode2 = 0 ;
21296 PyObject *swig_obj[2] ;
21297
21298 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21300 if (!SWIG_IsOK(res1)) {
21301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21302 }
21303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21304 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21305 if (!SWIG_IsOK(ecode2)) {
21306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21307 }
21308 arg2 = static_cast< bool >(val2);
21309 if (arg1) (arg1)->m_shiftDown = arg2;
21310
21311 resultobj = SWIG_Py_Void();
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 bool result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 result = (bool) ((arg1)->m_shiftDown);
21334 {
21335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21336 }
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *resultobj = 0;
21345 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21346 bool arg2 ;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 bool val2 ;
21350 int ecode2 = 0 ;
21351 PyObject *swig_obj[2] ;
21352
21353 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
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_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21357 }
21358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21359 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21360 if (!SWIG_IsOK(ecode2)) {
21361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21362 }
21363 arg2 = static_cast< bool >(val2);
21364 if (arg1) (arg1)->m_altDown = arg2;
21365
21366 resultobj = SWIG_Py_Void();
21367 return resultobj;
21368 fail:
21369 return NULL;
21370 }
21371
21372
21373 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21374 PyObject *resultobj = 0;
21375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21376 bool result;
21377 void *argp1 = 0 ;
21378 int res1 = 0 ;
21379 PyObject *swig_obj[1] ;
21380
21381 if (!args) SWIG_fail;
21382 swig_obj[0] = args;
21383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21384 if (!SWIG_IsOK(res1)) {
21385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21386 }
21387 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21388 result = (bool) ((arg1)->m_altDown);
21389 {
21390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21391 }
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21399 PyObject *resultobj = 0;
21400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21401 bool arg2 ;
21402 void *argp1 = 0 ;
21403 int res1 = 0 ;
21404 bool val2 ;
21405 int ecode2 = 0 ;
21406 PyObject *swig_obj[2] ;
21407
21408 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
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_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21412 }
21413 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21414 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21415 if (!SWIG_IsOK(ecode2)) {
21416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21417 }
21418 arg2 = static_cast< bool >(val2);
21419 if (arg1) (arg1)->m_metaDown = arg2;
21420
21421 resultobj = SWIG_Py_Void();
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21431 bool result;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 PyObject *swig_obj[1] ;
21435
21436 if (!args) SWIG_fail;
21437 swig_obj[0] = args;
21438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21439 if (!SWIG_IsOK(res1)) {
21440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21441 }
21442 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21443 result = (bool) ((arg1)->m_metaDown);
21444 {
21445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21446 }
21447 return resultobj;
21448 fail:
21449 return NULL;
21450 }
21451
21452
21453 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21454 PyObject *resultobj = 0;
21455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21456 int arg2 ;
21457 void *argp1 = 0 ;
21458 int res1 = 0 ;
21459 int val2 ;
21460 int ecode2 = 0 ;
21461 PyObject *swig_obj[2] ;
21462
21463 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
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_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21467 }
21468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21469 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21470 if (!SWIG_IsOK(ecode2)) {
21471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21472 }
21473 arg2 = static_cast< int >(val2);
21474 if (arg1) (arg1)->m_wheelRotation = arg2;
21475
21476 resultobj = SWIG_Py_Void();
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *resultobj = 0;
21485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21486 int result;
21487 void *argp1 = 0 ;
21488 int res1 = 0 ;
21489 PyObject *swig_obj[1] ;
21490
21491 if (!args) SWIG_fail;
21492 swig_obj[0] = args;
21493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21494 if (!SWIG_IsOK(res1)) {
21495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21496 }
21497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21498 result = (int) ((arg1)->m_wheelRotation);
21499 resultobj = SWIG_From_int(static_cast< int >(result));
21500 return resultobj;
21501 fail:
21502 return NULL;
21503 }
21504
21505
21506 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21507 PyObject *resultobj = 0;
21508 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21509 int arg2 ;
21510 void *argp1 = 0 ;
21511 int res1 = 0 ;
21512 int val2 ;
21513 int ecode2 = 0 ;
21514 PyObject *swig_obj[2] ;
21515
21516 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21518 if (!SWIG_IsOK(res1)) {
21519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21520 }
21521 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21522 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21523 if (!SWIG_IsOK(ecode2)) {
21524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21525 }
21526 arg2 = static_cast< int >(val2);
21527 if (arg1) (arg1)->m_wheelDelta = arg2;
21528
21529 resultobj = SWIG_Py_Void();
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21537 PyObject *resultobj = 0;
21538 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21539 int result;
21540 void *argp1 = 0 ;
21541 int res1 = 0 ;
21542 PyObject *swig_obj[1] ;
21543
21544 if (!args) SWIG_fail;
21545 swig_obj[0] = args;
21546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21547 if (!SWIG_IsOK(res1)) {
21548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21549 }
21550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21551 result = (int) ((arg1)->m_wheelDelta);
21552 resultobj = SWIG_From_int(static_cast< int >(result));
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21560 PyObject *resultobj = 0;
21561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21562 int arg2 ;
21563 void *argp1 = 0 ;
21564 int res1 = 0 ;
21565 int val2 ;
21566 int ecode2 = 0 ;
21567 PyObject *swig_obj[2] ;
21568
21569 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21571 if (!SWIG_IsOK(res1)) {
21572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21573 }
21574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21575 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21576 if (!SWIG_IsOK(ecode2)) {
21577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21578 }
21579 arg2 = static_cast< int >(val2);
21580 if (arg1) (arg1)->m_linesPerAction = arg2;
21581
21582 resultobj = SWIG_Py_Void();
21583 return resultobj;
21584 fail:
21585 return NULL;
21586 }
21587
21588
21589 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21590 PyObject *resultobj = 0;
21591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21592 int result;
21593 void *argp1 = 0 ;
21594 int res1 = 0 ;
21595 PyObject *swig_obj[1] ;
21596
21597 if (!args) SWIG_fail;
21598 swig_obj[0] = args;
21599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21600 if (!SWIG_IsOK(res1)) {
21601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21602 }
21603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21604 result = (int) ((arg1)->m_linesPerAction);
21605 resultobj = SWIG_From_int(static_cast< int >(result));
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *obj;
21614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21615 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21616 return SWIG_Py_Void();
21617 }
21618
21619 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21620 return SWIG_Python_InitShadowInstance(args);
21621 }
21622
21623 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21624 PyObject *resultobj = 0;
21625 int arg1 = (int) 0 ;
21626 int arg2 = (int) 0 ;
21627 wxSetCursorEvent *result = 0 ;
21628 int val1 ;
21629 int ecode1 = 0 ;
21630 int val2 ;
21631 int ecode2 = 0 ;
21632 PyObject * obj0 = 0 ;
21633 PyObject * obj1 = 0 ;
21634 char * kwnames[] = {
21635 (char *) "x",(char *) "y", NULL
21636 };
21637
21638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21639 if (obj0) {
21640 ecode1 = SWIG_AsVal_int(obj0, &val1);
21641 if (!SWIG_IsOK(ecode1)) {
21642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21643 }
21644 arg1 = static_cast< int >(val1);
21645 }
21646 if (obj1) {
21647 ecode2 = SWIG_AsVal_int(obj1, &val2);
21648 if (!SWIG_IsOK(ecode2)) {
21649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21650 }
21651 arg2 = static_cast< int >(val2);
21652 }
21653 {
21654 PyThreadState* __tstate = wxPyBeginAllowThreads();
21655 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *resultobj = 0;
21668 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21669 int result;
21670 void *argp1 = 0 ;
21671 int res1 = 0 ;
21672 PyObject *swig_obj[1] ;
21673
21674 if (!args) SWIG_fail;
21675 swig_obj[0] = args;
21676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21679 }
21680 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21681 {
21682 PyThreadState* __tstate = wxPyBeginAllowThreads();
21683 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21684 wxPyEndAllowThreads(__tstate);
21685 if (PyErr_Occurred()) SWIG_fail;
21686 }
21687 resultobj = SWIG_From_int(static_cast< int >(result));
21688 return resultobj;
21689 fail:
21690 return NULL;
21691 }
21692
21693
21694 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21695 PyObject *resultobj = 0;
21696 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21697 int result;
21698 void *argp1 = 0 ;
21699 int res1 = 0 ;
21700 PyObject *swig_obj[1] ;
21701
21702 if (!args) SWIG_fail;
21703 swig_obj[0] = args;
21704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21705 if (!SWIG_IsOK(res1)) {
21706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21707 }
21708 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21709 {
21710 PyThreadState* __tstate = wxPyBeginAllowThreads();
21711 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21712 wxPyEndAllowThreads(__tstate);
21713 if (PyErr_Occurred()) SWIG_fail;
21714 }
21715 resultobj = SWIG_From_int(static_cast< int >(result));
21716 return resultobj;
21717 fail:
21718 return NULL;
21719 }
21720
21721
21722 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21723 PyObject *resultobj = 0;
21724 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21725 wxCursor *arg2 = 0 ;
21726 void *argp1 = 0 ;
21727 int res1 = 0 ;
21728 void *argp2 = 0 ;
21729 int res2 = 0 ;
21730 PyObject * obj0 = 0 ;
21731 PyObject * obj1 = 0 ;
21732 char * kwnames[] = {
21733 (char *) "self",(char *) "cursor", NULL
21734 };
21735
21736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21738 if (!SWIG_IsOK(res1)) {
21739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21740 }
21741 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21743 if (!SWIG_IsOK(res2)) {
21744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21745 }
21746 if (!argp2) {
21747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21748 }
21749 arg2 = reinterpret_cast< wxCursor * >(argp2);
21750 {
21751 PyThreadState* __tstate = wxPyBeginAllowThreads();
21752 (arg1)->SetCursor((wxCursor const &)*arg2);
21753 wxPyEndAllowThreads(__tstate);
21754 if (PyErr_Occurred()) SWIG_fail;
21755 }
21756 resultobj = SWIG_Py_Void();
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21764 PyObject *resultobj = 0;
21765 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21766 wxCursor *result = 0 ;
21767 void *argp1 = 0 ;
21768 int res1 = 0 ;
21769 PyObject *swig_obj[1] ;
21770
21771 if (!args) SWIG_fail;
21772 swig_obj[0] = args;
21773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21774 if (!SWIG_IsOK(res1)) {
21775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21776 }
21777 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21778 {
21779 PyThreadState* __tstate = wxPyBeginAllowThreads();
21780 {
21781 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21782 result = (wxCursor *) &_result_ref;
21783 }
21784 wxPyEndAllowThreads(__tstate);
21785 if (PyErr_Occurred()) SWIG_fail;
21786 }
21787 {
21788 wxCursor* resultptr = new wxCursor(*result);
21789 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21790 }
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21800 bool result;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 PyObject *swig_obj[1] ;
21804
21805 if (!args) SWIG_fail;
21806 swig_obj[0] = args;
21807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21808 if (!SWIG_IsOK(res1)) {
21809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21810 }
21811 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 {
21819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21820 }
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21828 PyObject *obj;
21829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21830 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21831 return SWIG_Py_Void();
21832 }
21833
21834 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21835 return SWIG_Python_InitShadowInstance(args);
21836 }
21837
21838 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21839 PyObject *resultobj = 0;
21840 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21841 wxKeyEvent *result = 0 ;
21842 int val1 ;
21843 int ecode1 = 0 ;
21844 PyObject * obj0 = 0 ;
21845 char * kwnames[] = {
21846 (char *) "eventType", NULL
21847 };
21848
21849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21850 if (obj0) {
21851 ecode1 = SWIG_AsVal_int(obj0, &val1);
21852 if (!SWIG_IsOK(ecode1)) {
21853 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21854 }
21855 arg1 = static_cast< wxEventType >(val1);
21856 }
21857 {
21858 PyThreadState* __tstate = wxPyBeginAllowThreads();
21859 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21864 return resultobj;
21865 fail:
21866 return NULL;
21867 }
21868
21869
21870 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 PyObject *resultobj = 0;
21872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21873 int result;
21874 void *argp1 = 0 ;
21875 int res1 = 0 ;
21876 PyObject *swig_obj[1] ;
21877
21878 if (!args) SWIG_fail;
21879 swig_obj[0] = args;
21880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21881 if (!SWIG_IsOK(res1)) {
21882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21883 }
21884 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21885 {
21886 PyThreadState* __tstate = wxPyBeginAllowThreads();
21887 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21888 wxPyEndAllowThreads(__tstate);
21889 if (PyErr_Occurred()) SWIG_fail;
21890 }
21891 resultobj = SWIG_From_int(static_cast< int >(result));
21892 return resultobj;
21893 fail:
21894 return NULL;
21895 }
21896
21897
21898 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21899 PyObject *resultobj = 0;
21900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21901 bool result;
21902 void *argp1 = 0 ;
21903 int res1 = 0 ;
21904 PyObject *swig_obj[1] ;
21905
21906 if (!args) SWIG_fail;
21907 swig_obj[0] = args;
21908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21909 if (!SWIG_IsOK(res1)) {
21910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21911 }
21912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 {
21920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21921 }
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21929 PyObject *resultobj = 0;
21930 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21931 bool result;
21932 void *argp1 = 0 ;
21933 int res1 = 0 ;
21934 PyObject *swig_obj[1] ;
21935
21936 if (!args) SWIG_fail;
21937 swig_obj[0] = args;
21938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21939 if (!SWIG_IsOK(res1)) {
21940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21941 }
21942 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21946 wxPyEndAllowThreads(__tstate);
21947 if (PyErr_Occurred()) SWIG_fail;
21948 }
21949 {
21950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21951 }
21952 return resultobj;
21953 fail:
21954 return NULL;
21955 }
21956
21957
21958 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21959 PyObject *resultobj = 0;
21960 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21961 bool result;
21962 void *argp1 = 0 ;
21963 int res1 = 0 ;
21964 PyObject *swig_obj[1] ;
21965
21966 if (!args) SWIG_fail;
21967 swig_obj[0] = args;
21968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21969 if (!SWIG_IsOK(res1)) {
21970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21971 }
21972 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21973 {
21974 PyThreadState* __tstate = wxPyBeginAllowThreads();
21975 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21976 wxPyEndAllowThreads(__tstate);
21977 if (PyErr_Occurred()) SWIG_fail;
21978 }
21979 {
21980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21981 }
21982 return resultobj;
21983 fail:
21984 return NULL;
21985 }
21986
21987
21988 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21989 PyObject *resultobj = 0;
21990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21991 bool result;
21992 void *argp1 = 0 ;
21993 int res1 = 0 ;
21994 PyObject *swig_obj[1] ;
21995
21996 if (!args) SWIG_fail;
21997 swig_obj[0] = args;
21998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21999 if (!SWIG_IsOK(res1)) {
22000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22001 }
22002 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22003 {
22004 PyThreadState* __tstate = wxPyBeginAllowThreads();
22005 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22006 wxPyEndAllowThreads(__tstate);
22007 if (PyErr_Occurred()) SWIG_fail;
22008 }
22009 {
22010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22011 }
22012 return resultobj;
22013 fail:
22014 return NULL;
22015 }
22016
22017
22018 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22019 PyObject *resultobj = 0;
22020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22021 bool result;
22022 void *argp1 = 0 ;
22023 int res1 = 0 ;
22024 PyObject *swig_obj[1] ;
22025
22026 if (!args) SWIG_fail;
22027 swig_obj[0] = args;
22028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22029 if (!SWIG_IsOK(res1)) {
22030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22031 }
22032 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22033 {
22034 PyThreadState* __tstate = wxPyBeginAllowThreads();
22035 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22036 wxPyEndAllowThreads(__tstate);
22037 if (PyErr_Occurred()) SWIG_fail;
22038 }
22039 {
22040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22041 }
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22049 PyObject *resultobj = 0;
22050 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22051 bool result;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 PyObject *swig_obj[1] ;
22055
22056 if (!args) SWIG_fail;
22057 swig_obj[0] = args;
22058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22059 if (!SWIG_IsOK(res1)) {
22060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22061 }
22062 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 {
22070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22071 }
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 PyObject *resultobj = 0;
22080 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22081 int result;
22082 void *argp1 = 0 ;
22083 int res1 = 0 ;
22084 PyObject *swig_obj[1] ;
22085
22086 if (!args) SWIG_fail;
22087 swig_obj[0] = args;
22088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22089 if (!SWIG_IsOK(res1)) {
22090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22091 }
22092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 resultobj = SWIG_From_int(static_cast< int >(result));
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22107 PyObject *resultobj = 0;
22108 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22109 int result;
22110 void *argp1 = 0 ;
22111 int res1 = 0 ;
22112 PyObject *swig_obj[1] ;
22113
22114 if (!args) SWIG_fail;
22115 swig_obj[0] = args;
22116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22117 if (!SWIG_IsOK(res1)) {
22118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22119 }
22120 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22121 {
22122 PyThreadState* __tstate = wxPyBeginAllowThreads();
22123 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22124 wxPyEndAllowThreads(__tstate);
22125 if (PyErr_Occurred()) SWIG_fail;
22126 }
22127 resultobj = SWIG_From_int(static_cast< int >(result));
22128 return resultobj;
22129 fail:
22130 return NULL;
22131 }
22132
22133
22134 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22135 PyObject *resultobj = 0;
22136 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22137 unsigned int result;
22138 void *argp1 = 0 ;
22139 int res1 = 0 ;
22140 PyObject *swig_obj[1] ;
22141
22142 if (!args) SWIG_fail;
22143 swig_obj[0] = args;
22144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22145 if (!SWIG_IsOK(res1)) {
22146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22147 }
22148 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22149 {
22150 PyThreadState* __tstate = wxPyBeginAllowThreads();
22151 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22152 wxPyEndAllowThreads(__tstate);
22153 if (PyErr_Occurred()) SWIG_fail;
22154 }
22155 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22156 return resultobj;
22157 fail:
22158 return NULL;
22159 }
22160
22161
22162 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22163 PyObject *resultobj = 0;
22164 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22165 unsigned int result;
22166 void *argp1 = 0 ;
22167 int res1 = 0 ;
22168 PyObject *swig_obj[1] ;
22169
22170 if (!args) SWIG_fail;
22171 swig_obj[0] = args;
22172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22173 if (!SWIG_IsOK(res1)) {
22174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22175 }
22176 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22177 {
22178 PyThreadState* __tstate = wxPyBeginAllowThreads();
22179 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22180 wxPyEndAllowThreads(__tstate);
22181 if (PyErr_Occurred()) SWIG_fail;
22182 }
22183 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22184 return resultobj;
22185 fail:
22186 return NULL;
22187 }
22188
22189
22190 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22191 PyObject *resultobj = 0;
22192 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22193 wxPoint result;
22194 void *argp1 = 0 ;
22195 int res1 = 0 ;
22196 PyObject *swig_obj[1] ;
22197
22198 if (!args) SWIG_fail;
22199 swig_obj[0] = args;
22200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22201 if (!SWIG_IsOK(res1)) {
22202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22203 }
22204 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22205 {
22206 PyThreadState* __tstate = wxPyBeginAllowThreads();
22207 result = (arg1)->GetPosition();
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22219 PyObject *resultobj = 0;
22220 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22221 long *arg2 = (long *) 0 ;
22222 long *arg3 = (long *) 0 ;
22223 void *argp1 = 0 ;
22224 int res1 = 0 ;
22225 long temp2 ;
22226 int res2 = SWIG_TMPOBJ ;
22227 long temp3 ;
22228 int res3 = SWIG_TMPOBJ ;
22229 PyObject *swig_obj[1] ;
22230
22231 arg2 = &temp2;
22232 arg3 = &temp3;
22233 if (!args) SWIG_fail;
22234 swig_obj[0] = args;
22235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22238 }
22239 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 (arg1)->GetPosition(arg2,arg3);
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 resultobj = SWIG_Py_Void();
22247 if (SWIG_IsTmpObj(res2)) {
22248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22249 } else {
22250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22252 }
22253 if (SWIG_IsTmpObj(res3)) {
22254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22255 } else {
22256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22258 }
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266 PyObject *resultobj = 0;
22267 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22268 int result;
22269 void *argp1 = 0 ;
22270 int res1 = 0 ;
22271 PyObject *swig_obj[1] ;
22272
22273 if (!args) SWIG_fail;
22274 swig_obj[0] = args;
22275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22276 if (!SWIG_IsOK(res1)) {
22277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22278 }
22279 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22280 {
22281 PyThreadState* __tstate = wxPyBeginAllowThreads();
22282 result = (int)((wxKeyEvent const *)arg1)->GetX();
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 resultobj = SWIG_From_int(static_cast< int >(result));
22287 return resultobj;
22288 fail:
22289 return NULL;
22290 }
22291
22292
22293 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22294 PyObject *resultobj = 0;
22295 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22296 int result;
22297 void *argp1 = 0 ;
22298 int res1 = 0 ;
22299 PyObject *swig_obj[1] ;
22300
22301 if (!args) SWIG_fail;
22302 swig_obj[0] = args;
22303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22304 if (!SWIG_IsOK(res1)) {
22305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22306 }
22307 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (int)((wxKeyEvent const *)arg1)->GetY();
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 resultobj = SWIG_From_int(static_cast< int >(result));
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22322 PyObject *resultobj = 0;
22323 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22324 int arg2 ;
22325 void *argp1 = 0 ;
22326 int res1 = 0 ;
22327 int val2 ;
22328 int ecode2 = 0 ;
22329 PyObject *swig_obj[2] ;
22330
22331 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22333 if (!SWIG_IsOK(res1)) {
22334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22335 }
22336 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22337 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22338 if (!SWIG_IsOK(ecode2)) {
22339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22340 }
22341 arg2 = static_cast< int >(val2);
22342 if (arg1) (arg1)->m_x = arg2;
22343
22344 resultobj = SWIG_Py_Void();
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22354 int result;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 PyObject *swig_obj[1] ;
22358
22359 if (!args) SWIG_fail;
22360 swig_obj[0] = args;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22364 }
22365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22366 result = (int) ((arg1)->m_x);
22367 resultobj = SWIG_From_int(static_cast< int >(result));
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22377 int arg2 ;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 int val2 ;
22381 int ecode2 = 0 ;
22382 PyObject *swig_obj[2] ;
22383
22384 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22386 if (!SWIG_IsOK(res1)) {
22387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22388 }
22389 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22390 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22391 if (!SWIG_IsOK(ecode2)) {
22392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22393 }
22394 arg2 = static_cast< int >(val2);
22395 if (arg1) (arg1)->m_y = arg2;
22396
22397 resultobj = SWIG_Py_Void();
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *resultobj = 0;
22406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22407 int result;
22408 void *argp1 = 0 ;
22409 int res1 = 0 ;
22410 PyObject *swig_obj[1] ;
22411
22412 if (!args) SWIG_fail;
22413 swig_obj[0] = args;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22417 }
22418 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22419 result = (int) ((arg1)->m_y);
22420 resultobj = SWIG_From_int(static_cast< int >(result));
22421 return resultobj;
22422 fail:
22423 return NULL;
22424 }
22425
22426
22427 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22428 PyObject *resultobj = 0;
22429 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22430 long arg2 ;
22431 void *argp1 = 0 ;
22432 int res1 = 0 ;
22433 long val2 ;
22434 int ecode2 = 0 ;
22435 PyObject *swig_obj[2] ;
22436
22437 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22439 if (!SWIG_IsOK(res1)) {
22440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22441 }
22442 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22443 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22444 if (!SWIG_IsOK(ecode2)) {
22445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22446 }
22447 arg2 = static_cast< long >(val2);
22448 if (arg1) (arg1)->m_keyCode = arg2;
22449
22450 resultobj = SWIG_Py_Void();
22451 return resultobj;
22452 fail:
22453 return NULL;
22454 }
22455
22456
22457 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22458 PyObject *resultobj = 0;
22459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22460 long result;
22461 void *argp1 = 0 ;
22462 int res1 = 0 ;
22463 PyObject *swig_obj[1] ;
22464
22465 if (!args) SWIG_fail;
22466 swig_obj[0] = args;
22467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22472 result = (long) ((arg1)->m_keyCode);
22473 resultobj = SWIG_From_long(static_cast< long >(result));
22474 return resultobj;
22475 fail:
22476 return NULL;
22477 }
22478
22479
22480 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22481 PyObject *resultobj = 0;
22482 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22483 bool arg2 ;
22484 void *argp1 = 0 ;
22485 int res1 = 0 ;
22486 bool val2 ;
22487 int ecode2 = 0 ;
22488 PyObject *swig_obj[2] ;
22489
22490 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22492 if (!SWIG_IsOK(res1)) {
22493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22494 }
22495 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22496 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22497 if (!SWIG_IsOK(ecode2)) {
22498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22499 }
22500 arg2 = static_cast< bool >(val2);
22501 if (arg1) (arg1)->m_controlDown = arg2;
22502
22503 resultobj = SWIG_Py_Void();
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *resultobj = 0;
22512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22513 bool result;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 PyObject *swig_obj[1] ;
22517
22518 if (!args) SWIG_fail;
22519 swig_obj[0] = args;
22520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22523 }
22524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22525 result = (bool) ((arg1)->m_controlDown);
22526 {
22527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22528 }
22529 return resultobj;
22530 fail:
22531 return NULL;
22532 }
22533
22534
22535 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 PyObject *resultobj = 0;
22537 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22538 bool arg2 ;
22539 void *argp1 = 0 ;
22540 int res1 = 0 ;
22541 bool val2 ;
22542 int ecode2 = 0 ;
22543 PyObject *swig_obj[2] ;
22544
22545 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22547 if (!SWIG_IsOK(res1)) {
22548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22549 }
22550 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22551 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22552 if (!SWIG_IsOK(ecode2)) {
22553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22554 }
22555 arg2 = static_cast< bool >(val2);
22556 if (arg1) (arg1)->m_shiftDown = arg2;
22557
22558 resultobj = SWIG_Py_Void();
22559 return resultobj;
22560 fail:
22561 return NULL;
22562 }
22563
22564
22565 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22566 PyObject *resultobj = 0;
22567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22568 bool result;
22569 void *argp1 = 0 ;
22570 int res1 = 0 ;
22571 PyObject *swig_obj[1] ;
22572
22573 if (!args) SWIG_fail;
22574 swig_obj[0] = args;
22575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22576 if (!SWIG_IsOK(res1)) {
22577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22578 }
22579 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22580 result = (bool) ((arg1)->m_shiftDown);
22581 {
22582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22583 }
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22591 PyObject *resultobj = 0;
22592 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22593 bool arg2 ;
22594 void *argp1 = 0 ;
22595 int res1 = 0 ;
22596 bool val2 ;
22597 int ecode2 = 0 ;
22598 PyObject *swig_obj[2] ;
22599
22600 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22602 if (!SWIG_IsOK(res1)) {
22603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22604 }
22605 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22606 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22607 if (!SWIG_IsOK(ecode2)) {
22608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22609 }
22610 arg2 = static_cast< bool >(val2);
22611 if (arg1) (arg1)->m_altDown = arg2;
22612
22613 resultobj = SWIG_Py_Void();
22614 return resultobj;
22615 fail:
22616 return NULL;
22617 }
22618
22619
22620 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22621 PyObject *resultobj = 0;
22622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22623 bool result;
22624 void *argp1 = 0 ;
22625 int res1 = 0 ;
22626 PyObject *swig_obj[1] ;
22627
22628 if (!args) SWIG_fail;
22629 swig_obj[0] = args;
22630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22631 if (!SWIG_IsOK(res1)) {
22632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22633 }
22634 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22635 result = (bool) ((arg1)->m_altDown);
22636 {
22637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22638 }
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22646 PyObject *resultobj = 0;
22647 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22648 bool arg2 ;
22649 void *argp1 = 0 ;
22650 int res1 = 0 ;
22651 bool val2 ;
22652 int ecode2 = 0 ;
22653 PyObject *swig_obj[2] ;
22654
22655 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22657 if (!SWIG_IsOK(res1)) {
22658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22659 }
22660 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22661 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22662 if (!SWIG_IsOK(ecode2)) {
22663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22664 }
22665 arg2 = static_cast< bool >(val2);
22666 if (arg1) (arg1)->m_metaDown = arg2;
22667
22668 resultobj = SWIG_Py_Void();
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22676 PyObject *resultobj = 0;
22677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22678 bool result;
22679 void *argp1 = 0 ;
22680 int res1 = 0 ;
22681 PyObject *swig_obj[1] ;
22682
22683 if (!args) SWIG_fail;
22684 swig_obj[0] = args;
22685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22686 if (!SWIG_IsOK(res1)) {
22687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22688 }
22689 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22690 result = (bool) ((arg1)->m_metaDown);
22691 {
22692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22693 }
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22701 PyObject *resultobj = 0;
22702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22703 bool arg2 ;
22704 void *argp1 = 0 ;
22705 int res1 = 0 ;
22706 bool val2 ;
22707 int ecode2 = 0 ;
22708 PyObject *swig_obj[2] ;
22709
22710 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22712 if (!SWIG_IsOK(res1)) {
22713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22714 }
22715 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22716 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22717 if (!SWIG_IsOK(ecode2)) {
22718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22719 }
22720 arg2 = static_cast< bool >(val2);
22721 if (arg1) (arg1)->m_scanCode = arg2;
22722
22723 resultobj = SWIG_Py_Void();
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22731 PyObject *resultobj = 0;
22732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22733 bool result;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 PyObject *swig_obj[1] ;
22737
22738 if (!args) SWIG_fail;
22739 swig_obj[0] = args;
22740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22741 if (!SWIG_IsOK(res1)) {
22742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22743 }
22744 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22745 result = (bool) ((arg1)->m_scanCode);
22746 {
22747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22748 }
22749 return resultobj;
22750 fail:
22751 return NULL;
22752 }
22753
22754
22755 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22756 PyObject *resultobj = 0;
22757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22758 unsigned int arg2 ;
22759 void *argp1 = 0 ;
22760 int res1 = 0 ;
22761 unsigned int val2 ;
22762 int ecode2 = 0 ;
22763 PyObject *swig_obj[2] ;
22764
22765 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22767 if (!SWIG_IsOK(res1)) {
22768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22769 }
22770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22771 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22772 if (!SWIG_IsOK(ecode2)) {
22773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22774 }
22775 arg2 = static_cast< unsigned int >(val2);
22776 if (arg1) (arg1)->m_rawCode = arg2;
22777
22778 resultobj = SWIG_Py_Void();
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22786 PyObject *resultobj = 0;
22787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22788 unsigned int result;
22789 void *argp1 = 0 ;
22790 int res1 = 0 ;
22791 PyObject *swig_obj[1] ;
22792
22793 if (!args) SWIG_fail;
22794 swig_obj[0] = args;
22795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22796 if (!SWIG_IsOK(res1)) {
22797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22798 }
22799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22800 result = (unsigned int) ((arg1)->m_rawCode);
22801 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22802 return resultobj;
22803 fail:
22804 return NULL;
22805 }
22806
22807
22808 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22809 PyObject *resultobj = 0;
22810 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22811 unsigned int arg2 ;
22812 void *argp1 = 0 ;
22813 int res1 = 0 ;
22814 unsigned int val2 ;
22815 int ecode2 = 0 ;
22816 PyObject *swig_obj[2] ;
22817
22818 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22820 if (!SWIG_IsOK(res1)) {
22821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22822 }
22823 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22824 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22825 if (!SWIG_IsOK(ecode2)) {
22826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22827 }
22828 arg2 = static_cast< unsigned int >(val2);
22829 if (arg1) (arg1)->m_rawFlags = arg2;
22830
22831 resultobj = SWIG_Py_Void();
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22841 unsigned int result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22851 }
22852 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22853 result = (unsigned int) ((arg1)->m_rawFlags);
22854 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22855 return resultobj;
22856 fail:
22857 return NULL;
22858 }
22859
22860
22861 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22862 PyObject *obj;
22863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22864 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22865 return SWIG_Py_Void();
22866 }
22867
22868 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 return SWIG_Python_InitShadowInstance(args);
22870 }
22871
22872 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22873 PyObject *resultobj = 0;
22874 wxSize const &arg1_defvalue = wxDefaultSize ;
22875 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22876 int arg2 = (int) 0 ;
22877 wxSizeEvent *result = 0 ;
22878 wxSize temp1 ;
22879 int val2 ;
22880 int ecode2 = 0 ;
22881 PyObject * obj0 = 0 ;
22882 PyObject * obj1 = 0 ;
22883 char * kwnames[] = {
22884 (char *) "sz",(char *) "winid", NULL
22885 };
22886
22887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22888 if (obj0) {
22889 {
22890 arg1 = &temp1;
22891 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22892 }
22893 }
22894 if (obj1) {
22895 ecode2 = SWIG_AsVal_int(obj1, &val2);
22896 if (!SWIG_IsOK(ecode2)) {
22897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22898 }
22899 arg2 = static_cast< int >(val2);
22900 }
22901 {
22902 PyThreadState* __tstate = wxPyBeginAllowThreads();
22903 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22904 wxPyEndAllowThreads(__tstate);
22905 if (PyErr_Occurred()) SWIG_fail;
22906 }
22907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22915 PyObject *resultobj = 0;
22916 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22917 wxSize result;
22918 void *argp1 = 0 ;
22919 int res1 = 0 ;
22920 PyObject *swig_obj[1] ;
22921
22922 if (!args) SWIG_fail;
22923 swig_obj[0] = args;
22924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22925 if (!SWIG_IsOK(res1)) {
22926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22927 }
22928 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22929 {
22930 PyThreadState* __tstate = wxPyBeginAllowThreads();
22931 result = ((wxSizeEvent const *)arg1)->GetSize();
22932 wxPyEndAllowThreads(__tstate);
22933 if (PyErr_Occurred()) SWIG_fail;
22934 }
22935 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22936 return resultobj;
22937 fail:
22938 return NULL;
22939 }
22940
22941
22942 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22943 PyObject *resultobj = 0;
22944 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22945 wxRect result;
22946 void *argp1 = 0 ;
22947 int res1 = 0 ;
22948 PyObject *swig_obj[1] ;
22949
22950 if (!args) SWIG_fail;
22951 swig_obj[0] = args;
22952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22953 if (!SWIG_IsOK(res1)) {
22954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22955 }
22956 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22957 {
22958 PyThreadState* __tstate = wxPyBeginAllowThreads();
22959 result = ((wxSizeEvent const *)arg1)->GetRect();
22960 wxPyEndAllowThreads(__tstate);
22961 if (PyErr_Occurred()) SWIG_fail;
22962 }
22963 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22964 return resultobj;
22965 fail:
22966 return NULL;
22967 }
22968
22969
22970 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22971 PyObject *resultobj = 0;
22972 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22973 wxRect arg2 ;
22974 void *argp1 = 0 ;
22975 int res1 = 0 ;
22976 void *argp2 ;
22977 int res2 = 0 ;
22978 PyObject * obj0 = 0 ;
22979 PyObject * obj1 = 0 ;
22980 char * kwnames[] = {
22981 (char *) "self",(char *) "rect", NULL
22982 };
22983
22984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22986 if (!SWIG_IsOK(res1)) {
22987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22988 }
22989 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22990 {
22991 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22992 if (!SWIG_IsOK(res2)) {
22993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22994 }
22995 if (!argp2) {
22996 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22997 } else {
22998 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22999 arg2 = *temp;
23000 if (SWIG_IsNewObj(res2)) delete temp;
23001 }
23002 }
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 (arg1)->SetRect(arg2);
23006 wxPyEndAllowThreads(__tstate);
23007 if (PyErr_Occurred()) SWIG_fail;
23008 }
23009 resultobj = SWIG_Py_Void();
23010 return resultobj;
23011 fail:
23012 return NULL;
23013 }
23014
23015
23016 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23017 PyObject *resultobj = 0;
23018 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23019 wxSize arg2 ;
23020 void *argp1 = 0 ;
23021 int res1 = 0 ;
23022 void *argp2 ;
23023 int res2 = 0 ;
23024 PyObject * obj0 = 0 ;
23025 PyObject * obj1 = 0 ;
23026 char * kwnames[] = {
23027 (char *) "self",(char *) "size", NULL
23028 };
23029
23030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23034 }
23035 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23036 {
23037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23038 if (!SWIG_IsOK(res2)) {
23039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23040 }
23041 if (!argp2) {
23042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23043 } else {
23044 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23045 arg2 = *temp;
23046 if (SWIG_IsNewObj(res2)) delete temp;
23047 }
23048 }
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 wxSizeEvent_SetSize(arg1,arg2);
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 resultobj = SWIG_Py_Void();
23056 return resultobj;
23057 fail:
23058 return NULL;
23059 }
23060
23061
23062 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23063 PyObject *resultobj = 0;
23064 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23065 wxSize *arg2 = (wxSize *) 0 ;
23066 void *argp1 = 0 ;
23067 int res1 = 0 ;
23068 void *argp2 = 0 ;
23069 int res2 = 0 ;
23070 PyObject *swig_obj[2] ;
23071
23072 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23074 if (!SWIG_IsOK(res1)) {
23075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23076 }
23077 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23079 if (!SWIG_IsOK(res2)) {
23080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23081 }
23082 arg2 = reinterpret_cast< wxSize * >(argp2);
23083 if (arg1) (arg1)->m_size = *arg2;
23084
23085 resultobj = SWIG_Py_Void();
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *resultobj = 0;
23094 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23095 wxSize *result = 0 ;
23096 void *argp1 = 0 ;
23097 int res1 = 0 ;
23098 PyObject *swig_obj[1] ;
23099
23100 if (!args) SWIG_fail;
23101 swig_obj[0] = args;
23102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23103 if (!SWIG_IsOK(res1)) {
23104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23105 }
23106 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23107 result = (wxSize *)& ((arg1)->m_size);
23108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23109 return resultobj;
23110 fail:
23111 return NULL;
23112 }
23113
23114
23115 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23116 PyObject *resultobj = 0;
23117 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23118 wxRect *arg2 = (wxRect *) 0 ;
23119 void *argp1 = 0 ;
23120 int res1 = 0 ;
23121 void *argp2 = 0 ;
23122 int res2 = 0 ;
23123 PyObject *swig_obj[2] ;
23124
23125 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23127 if (!SWIG_IsOK(res1)) {
23128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23129 }
23130 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23131 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23132 if (!SWIG_IsOK(res2)) {
23133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23134 }
23135 arg2 = reinterpret_cast< wxRect * >(argp2);
23136 if (arg1) (arg1)->m_rect = *arg2;
23137
23138 resultobj = SWIG_Py_Void();
23139 return resultobj;
23140 fail:
23141 return NULL;
23142 }
23143
23144
23145 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23146 PyObject *resultobj = 0;
23147 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23148 wxRect *result = 0 ;
23149 void *argp1 = 0 ;
23150 int res1 = 0 ;
23151 PyObject *swig_obj[1] ;
23152
23153 if (!args) SWIG_fail;
23154 swig_obj[0] = args;
23155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23156 if (!SWIG_IsOK(res1)) {
23157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23158 }
23159 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23160 result = (wxRect *)& ((arg1)->m_rect);
23161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23162 return resultobj;
23163 fail:
23164 return NULL;
23165 }
23166
23167
23168 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23169 PyObject *obj;
23170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23171 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23172 return SWIG_Py_Void();
23173 }
23174
23175 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23176 return SWIG_Python_InitShadowInstance(args);
23177 }
23178
23179 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23180 PyObject *resultobj = 0;
23181 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23182 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23183 int arg2 = (int) 0 ;
23184 wxMoveEvent *result = 0 ;
23185 wxPoint temp1 ;
23186 int val2 ;
23187 int ecode2 = 0 ;
23188 PyObject * obj0 = 0 ;
23189 PyObject * obj1 = 0 ;
23190 char * kwnames[] = {
23191 (char *) "pos",(char *) "winid", NULL
23192 };
23193
23194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23195 if (obj0) {
23196 {
23197 arg1 = &temp1;
23198 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23199 }
23200 }
23201 if (obj1) {
23202 ecode2 = SWIG_AsVal_int(obj1, &val2);
23203 if (!SWIG_IsOK(ecode2)) {
23204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23205 }
23206 arg2 = static_cast< int >(val2);
23207 }
23208 {
23209 PyThreadState* __tstate = wxPyBeginAllowThreads();
23210 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 PyObject *resultobj = 0;
23223 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23224 wxPoint result;
23225 void *argp1 = 0 ;
23226 int res1 = 0 ;
23227 PyObject *swig_obj[1] ;
23228
23229 if (!args) SWIG_fail;
23230 swig_obj[0] = args;
23231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23232 if (!SWIG_IsOK(res1)) {
23233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23234 }
23235 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 result = ((wxMoveEvent const *)arg1)->GetPosition();
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23243 return resultobj;
23244 fail:
23245 return NULL;
23246 }
23247
23248
23249 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23250 PyObject *resultobj = 0;
23251 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23252 wxRect result;
23253 void *argp1 = 0 ;
23254 int res1 = 0 ;
23255 PyObject *swig_obj[1] ;
23256
23257 if (!args) SWIG_fail;
23258 swig_obj[0] = args;
23259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23260 if (!SWIG_IsOK(res1)) {
23261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23262 }
23263 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23264 {
23265 PyThreadState* __tstate = wxPyBeginAllowThreads();
23266 result = ((wxMoveEvent const *)arg1)->GetRect();
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23278 PyObject *resultobj = 0;
23279 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23280 wxRect *arg2 = 0 ;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 wxRect temp2 ;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 char * kwnames[] = {
23287 (char *) "self",(char *) "rect", NULL
23288 };
23289
23290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23292 if (!SWIG_IsOK(res1)) {
23293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23294 }
23295 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23296 {
23297 arg2 = &temp2;
23298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23299 }
23300 {
23301 PyThreadState* __tstate = wxPyBeginAllowThreads();
23302 (arg1)->SetRect((wxRect const &)*arg2);
23303 wxPyEndAllowThreads(__tstate);
23304 if (PyErr_Occurred()) SWIG_fail;
23305 }
23306 resultobj = SWIG_Py_Void();
23307 return resultobj;
23308 fail:
23309 return NULL;
23310 }
23311
23312
23313 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23314 PyObject *resultobj = 0;
23315 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23316 wxPoint *arg2 = 0 ;
23317 void *argp1 = 0 ;
23318 int res1 = 0 ;
23319 wxPoint temp2 ;
23320 PyObject * obj0 = 0 ;
23321 PyObject * obj1 = 0 ;
23322 char * kwnames[] = {
23323 (char *) "self",(char *) "pos", NULL
23324 };
23325
23326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23328 if (!SWIG_IsOK(res1)) {
23329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23330 }
23331 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23332 {
23333 arg2 = &temp2;
23334 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23335 }
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 (arg1)->SetPosition((wxPoint const &)*arg2);
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 resultobj = SWIG_Py_Void();
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 PyObject *obj;
23351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23352 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23353 return SWIG_Py_Void();
23354 }
23355
23356 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23357 return SWIG_Python_InitShadowInstance(args);
23358 }
23359
23360 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj = 0;
23362 int arg1 = (int) 0 ;
23363 wxPaintEvent *result = 0 ;
23364 int val1 ;
23365 int ecode1 = 0 ;
23366 PyObject * obj0 = 0 ;
23367 char * kwnames[] = {
23368 (char *) "Id", NULL
23369 };
23370
23371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23372 if (obj0) {
23373 ecode1 = SWIG_AsVal_int(obj0, &val1);
23374 if (!SWIG_IsOK(ecode1)) {
23375 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23376 }
23377 arg1 = static_cast< int >(val1);
23378 }
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 PyObject *obj;
23394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23395 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23396 return SWIG_Py_Void();
23397 }
23398
23399 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23400 return SWIG_Python_InitShadowInstance(args);
23401 }
23402
23403 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23404 PyObject *resultobj = 0;
23405 int arg1 = (int) 0 ;
23406 wxNcPaintEvent *result = 0 ;
23407 int val1 ;
23408 int ecode1 = 0 ;
23409 PyObject * obj0 = 0 ;
23410 char * kwnames[] = {
23411 (char *) "winid", NULL
23412 };
23413
23414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23415 if (obj0) {
23416 ecode1 = SWIG_AsVal_int(obj0, &val1);
23417 if (!SWIG_IsOK(ecode1)) {
23418 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23419 }
23420 arg1 = static_cast< int >(val1);
23421 }
23422 {
23423 PyThreadState* __tstate = wxPyBeginAllowThreads();
23424 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23429 return resultobj;
23430 fail:
23431 return NULL;
23432 }
23433
23434
23435 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23436 PyObject *obj;
23437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23438 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23439 return SWIG_Py_Void();
23440 }
23441
23442 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23443 return SWIG_Python_InitShadowInstance(args);
23444 }
23445
23446 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23447 PyObject *resultobj = 0;
23448 int arg1 = (int) 0 ;
23449 wxDC *arg2 = (wxDC *) NULL ;
23450 wxEraseEvent *result = 0 ;
23451 int val1 ;
23452 int ecode1 = 0 ;
23453 void *argp2 = 0 ;
23454 int res2 = 0 ;
23455 PyObject * obj0 = 0 ;
23456 PyObject * obj1 = 0 ;
23457 char * kwnames[] = {
23458 (char *) "Id",(char *) "dc", NULL
23459 };
23460
23461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23462 if (obj0) {
23463 ecode1 = SWIG_AsVal_int(obj0, &val1);
23464 if (!SWIG_IsOK(ecode1)) {
23465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23466 }
23467 arg1 = static_cast< int >(val1);
23468 }
23469 if (obj1) {
23470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23471 if (!SWIG_IsOK(res2)) {
23472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23473 }
23474 arg2 = reinterpret_cast< wxDC * >(argp2);
23475 }
23476 {
23477 PyThreadState* __tstate = wxPyBeginAllowThreads();
23478 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23479 wxPyEndAllowThreads(__tstate);
23480 if (PyErr_Occurred()) SWIG_fail;
23481 }
23482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23483 return resultobj;
23484 fail:
23485 return NULL;
23486 }
23487
23488
23489 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23490 PyObject *resultobj = 0;
23491 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23492 wxDC *result = 0 ;
23493 void *argp1 = 0 ;
23494 int res1 = 0 ;
23495 PyObject *swig_obj[1] ;
23496
23497 if (!args) SWIG_fail;
23498 swig_obj[0] = args;
23499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23500 if (!SWIG_IsOK(res1)) {
23501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23502 }
23503 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23504 {
23505 PyThreadState* __tstate = wxPyBeginAllowThreads();
23506 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23507 wxPyEndAllowThreads(__tstate);
23508 if (PyErr_Occurred()) SWIG_fail;
23509 }
23510 {
23511 resultobj = wxPyMake_wxObject(result, (bool)0);
23512 }
23513 return resultobj;
23514 fail:
23515 return NULL;
23516 }
23517
23518
23519 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23520 PyObject *obj;
23521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23522 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23523 return SWIG_Py_Void();
23524 }
23525
23526 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23527 return SWIG_Python_InitShadowInstance(args);
23528 }
23529
23530 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23531 PyObject *resultobj = 0;
23532 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23533 int arg2 = (int) 0 ;
23534 wxFocusEvent *result = 0 ;
23535 int val1 ;
23536 int ecode1 = 0 ;
23537 int val2 ;
23538 int ecode2 = 0 ;
23539 PyObject * obj0 = 0 ;
23540 PyObject * obj1 = 0 ;
23541 char * kwnames[] = {
23542 (char *) "type",(char *) "winid", NULL
23543 };
23544
23545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23546 if (obj0) {
23547 ecode1 = SWIG_AsVal_int(obj0, &val1);
23548 if (!SWIG_IsOK(ecode1)) {
23549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23550 }
23551 arg1 = static_cast< wxEventType >(val1);
23552 }
23553 if (obj1) {
23554 ecode2 = SWIG_AsVal_int(obj1, &val2);
23555 if (!SWIG_IsOK(ecode2)) {
23556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23557 }
23558 arg2 = static_cast< int >(val2);
23559 }
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23567 return resultobj;
23568 fail:
23569 return NULL;
23570 }
23571
23572
23573 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23574 PyObject *resultobj = 0;
23575 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23576 wxWindow *result = 0 ;
23577 void *argp1 = 0 ;
23578 int res1 = 0 ;
23579 PyObject *swig_obj[1] ;
23580
23581 if (!args) SWIG_fail;
23582 swig_obj[0] = args;
23583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23584 if (!SWIG_IsOK(res1)) {
23585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23586 }
23587 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 {
23595 resultobj = wxPyMake_wxObject(result, (bool)0);
23596 }
23597 return resultobj;
23598 fail:
23599 return NULL;
23600 }
23601
23602
23603 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23604 PyObject *resultobj = 0;
23605 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23606 wxWindow *arg2 = (wxWindow *) 0 ;
23607 void *argp1 = 0 ;
23608 int res1 = 0 ;
23609 void *argp2 = 0 ;
23610 int res2 = 0 ;
23611 PyObject * obj0 = 0 ;
23612 PyObject * obj1 = 0 ;
23613 char * kwnames[] = {
23614 (char *) "self",(char *) "win", NULL
23615 };
23616
23617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23619 if (!SWIG_IsOK(res1)) {
23620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23621 }
23622 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23624 if (!SWIG_IsOK(res2)) {
23625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23626 }
23627 arg2 = reinterpret_cast< wxWindow * >(argp2);
23628 {
23629 PyThreadState* __tstate = wxPyBeginAllowThreads();
23630 (arg1)->SetWindow(arg2);
23631 wxPyEndAllowThreads(__tstate);
23632 if (PyErr_Occurred()) SWIG_fail;
23633 }
23634 resultobj = SWIG_Py_Void();
23635 return resultobj;
23636 fail:
23637 return NULL;
23638 }
23639
23640
23641 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23642 PyObject *obj;
23643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23644 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23645 return SWIG_Py_Void();
23646 }
23647
23648 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23649 return SWIG_Python_InitShadowInstance(args);
23650 }
23651
23652 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj = 0;
23654 wxWindow *arg1 = (wxWindow *) NULL ;
23655 wxChildFocusEvent *result = 0 ;
23656 void *argp1 = 0 ;
23657 int res1 = 0 ;
23658 PyObject * obj0 = 0 ;
23659 char * kwnames[] = {
23660 (char *) "win", NULL
23661 };
23662
23663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23664 if (obj0) {
23665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23666 if (!SWIG_IsOK(res1)) {
23667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23668 }
23669 arg1 = reinterpret_cast< wxWindow * >(argp1);
23670 }
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23678 return resultobj;
23679 fail:
23680 return NULL;
23681 }
23682
23683
23684 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23685 PyObject *resultobj = 0;
23686 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23687 wxWindow *result = 0 ;
23688 void *argp1 = 0 ;
23689 int res1 = 0 ;
23690 PyObject *swig_obj[1] ;
23691
23692 if (!args) SWIG_fail;
23693 swig_obj[0] = args;
23694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23695 if (!SWIG_IsOK(res1)) {
23696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23697 }
23698 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 {
23706 resultobj = wxPyMake_wxObject(result, (bool)0);
23707 }
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23715 PyObject *obj;
23716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23717 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23718 return SWIG_Py_Void();
23719 }
23720
23721 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23722 return SWIG_Python_InitShadowInstance(args);
23723 }
23724
23725 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj = 0;
23727 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23728 bool arg2 = (bool) true ;
23729 int arg3 = (int) 0 ;
23730 wxActivateEvent *result = 0 ;
23731 int val1 ;
23732 int ecode1 = 0 ;
23733 bool val2 ;
23734 int ecode2 = 0 ;
23735 int val3 ;
23736 int ecode3 = 0 ;
23737 PyObject * obj0 = 0 ;
23738 PyObject * obj1 = 0 ;
23739 PyObject * obj2 = 0 ;
23740 char * kwnames[] = {
23741 (char *) "type",(char *) "active",(char *) "Id", NULL
23742 };
23743
23744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23745 if (obj0) {
23746 ecode1 = SWIG_AsVal_int(obj0, &val1);
23747 if (!SWIG_IsOK(ecode1)) {
23748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23749 }
23750 arg1 = static_cast< wxEventType >(val1);
23751 }
23752 if (obj1) {
23753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23754 if (!SWIG_IsOK(ecode2)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23756 }
23757 arg2 = static_cast< bool >(val2);
23758 }
23759 if (obj2) {
23760 ecode3 = SWIG_AsVal_int(obj2, &val3);
23761 if (!SWIG_IsOK(ecode3)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23763 }
23764 arg3 = static_cast< int >(val3);
23765 }
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23782 bool result;
23783 void *argp1 = 0 ;
23784 int res1 = 0 ;
23785 PyObject *swig_obj[1] ;
23786
23787 if (!args) SWIG_fail;
23788 swig_obj[0] = args;
23789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23790 if (!SWIG_IsOK(res1)) {
23791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23792 }
23793 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23794 {
23795 PyThreadState* __tstate = wxPyBeginAllowThreads();
23796 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23797 wxPyEndAllowThreads(__tstate);
23798 if (PyErr_Occurred()) SWIG_fail;
23799 }
23800 {
23801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23802 }
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *obj;
23811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23812 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23813 return SWIG_Py_Void();
23814 }
23815
23816 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23817 return SWIG_Python_InitShadowInstance(args);
23818 }
23819
23820 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj = 0;
23822 int arg1 = (int) 0 ;
23823 wxInitDialogEvent *result = 0 ;
23824 int val1 ;
23825 int ecode1 = 0 ;
23826 PyObject * obj0 = 0 ;
23827 char * kwnames[] = {
23828 (char *) "Id", NULL
23829 };
23830
23831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23832 if (obj0) {
23833 ecode1 = SWIG_AsVal_int(obj0, &val1);
23834 if (!SWIG_IsOK(ecode1)) {
23835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23836 }
23837 arg1 = static_cast< int >(val1);
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *obj;
23854 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23855 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23856 return SWIG_Py_Void();
23857 }
23858
23859 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23860 return SWIG_Python_InitShadowInstance(args);
23861 }
23862
23863 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23864 PyObject *resultobj = 0;
23865 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23866 int arg2 = (int) 0 ;
23867 wxMenu *arg3 = (wxMenu *) NULL ;
23868 wxMenuEvent *result = 0 ;
23869 int val1 ;
23870 int ecode1 = 0 ;
23871 int val2 ;
23872 int ecode2 = 0 ;
23873 void *argp3 = 0 ;
23874 int res3 = 0 ;
23875 PyObject * obj0 = 0 ;
23876 PyObject * obj1 = 0 ;
23877 PyObject * obj2 = 0 ;
23878 char * kwnames[] = {
23879 (char *) "type",(char *) "winid",(char *) "menu", NULL
23880 };
23881
23882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23883 if (obj0) {
23884 ecode1 = SWIG_AsVal_int(obj0, &val1);
23885 if (!SWIG_IsOK(ecode1)) {
23886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23887 }
23888 arg1 = static_cast< wxEventType >(val1);
23889 }
23890 if (obj1) {
23891 ecode2 = SWIG_AsVal_int(obj1, &val2);
23892 if (!SWIG_IsOK(ecode2)) {
23893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23894 }
23895 arg2 = static_cast< int >(val2);
23896 }
23897 if (obj2) {
23898 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23899 if (!SWIG_IsOK(res3)) {
23900 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23901 }
23902 arg3 = reinterpret_cast< wxMenu * >(argp3);
23903 }
23904 {
23905 PyThreadState* __tstate = wxPyBeginAllowThreads();
23906 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23907 wxPyEndAllowThreads(__tstate);
23908 if (PyErr_Occurred()) SWIG_fail;
23909 }
23910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23918 PyObject *resultobj = 0;
23919 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23920 int result;
23921 void *argp1 = 0 ;
23922 int res1 = 0 ;
23923 PyObject *swig_obj[1] ;
23924
23925 if (!args) SWIG_fail;
23926 swig_obj[0] = args;
23927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23928 if (!SWIG_IsOK(res1)) {
23929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23930 }
23931 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23932 {
23933 PyThreadState* __tstate = wxPyBeginAllowThreads();
23934 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23935 wxPyEndAllowThreads(__tstate);
23936 if (PyErr_Occurred()) SWIG_fail;
23937 }
23938 resultobj = SWIG_From_int(static_cast< int >(result));
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23946 PyObject *resultobj = 0;
23947 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23948 bool result;
23949 void *argp1 = 0 ;
23950 int res1 = 0 ;
23951 PyObject *swig_obj[1] ;
23952
23953 if (!args) SWIG_fail;
23954 swig_obj[0] = args;
23955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23958 }
23959 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *resultobj = 0;
23977 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23978 wxMenu *result = 0 ;
23979 void *argp1 = 0 ;
23980 int res1 = 0 ;
23981 PyObject *swig_obj[1] ;
23982
23983 if (!args) SWIG_fail;
23984 swig_obj[0] = args;
23985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23988 }
23989 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 {
23997 resultobj = wxPyMake_wxObject(result, (bool)0);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *obj;
24007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24008 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24009 return SWIG_Py_Void();
24010 }
24011
24012 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24013 return SWIG_Python_InitShadowInstance(args);
24014 }
24015
24016 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24017 PyObject *resultobj = 0;
24018 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24019 int arg2 = (int) 0 ;
24020 wxCloseEvent *result = 0 ;
24021 int val1 ;
24022 int ecode1 = 0 ;
24023 int val2 ;
24024 int ecode2 = 0 ;
24025 PyObject * obj0 = 0 ;
24026 PyObject * obj1 = 0 ;
24027 char * kwnames[] = {
24028 (char *) "type",(char *) "winid", NULL
24029 };
24030
24031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24032 if (obj0) {
24033 ecode1 = SWIG_AsVal_int(obj0, &val1);
24034 if (!SWIG_IsOK(ecode1)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24036 }
24037 arg1 = static_cast< wxEventType >(val1);
24038 }
24039 if (obj1) {
24040 ecode2 = SWIG_AsVal_int(obj1, &val2);
24041 if (!SWIG_IsOK(ecode2)) {
24042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24043 }
24044 arg2 = static_cast< int >(val2);
24045 }
24046 {
24047 PyThreadState* __tstate = wxPyBeginAllowThreads();
24048 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24060 PyObject *resultobj = 0;
24061 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24062 bool arg2 ;
24063 void *argp1 = 0 ;
24064 int res1 = 0 ;
24065 bool val2 ;
24066 int ecode2 = 0 ;
24067 PyObject * obj0 = 0 ;
24068 PyObject * obj1 = 0 ;
24069 char * kwnames[] = {
24070 (char *) "self",(char *) "logOff", NULL
24071 };
24072
24073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24077 }
24078 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24080 if (!SWIG_IsOK(ecode2)) {
24081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24082 }
24083 arg2 = static_cast< bool >(val2);
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 (arg1)->SetLoggingOff(arg2);
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_Py_Void();
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *resultobj = 0;
24099 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24100 bool result;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 PyObject *swig_obj[1] ;
24104
24105 if (!args) SWIG_fail;
24106 swig_obj[0] = args;
24107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24108 if (!SWIG_IsOK(res1)) {
24109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24110 }
24111 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24115 wxPyEndAllowThreads(__tstate);
24116 if (PyErr_Occurred()) SWIG_fail;
24117 }
24118 {
24119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24120 }
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24128 PyObject *resultobj = 0;
24129 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24130 bool arg2 = (bool) true ;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 bool val2 ;
24134 int ecode2 = 0 ;
24135 PyObject * obj0 = 0 ;
24136 PyObject * obj1 = 0 ;
24137 char * kwnames[] = {
24138 (char *) "self",(char *) "veto", NULL
24139 };
24140
24141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24143 if (!SWIG_IsOK(res1)) {
24144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24145 }
24146 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24147 if (obj1) {
24148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24149 if (!SWIG_IsOK(ecode2)) {
24150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24151 }
24152 arg2 = static_cast< bool >(val2);
24153 }
24154 {
24155 PyThreadState* __tstate = wxPyBeginAllowThreads();
24156 (arg1)->Veto(arg2);
24157 wxPyEndAllowThreads(__tstate);
24158 if (PyErr_Occurred()) SWIG_fail;
24159 }
24160 resultobj = SWIG_Py_Void();
24161 return resultobj;
24162 fail:
24163 return NULL;
24164 }
24165
24166
24167 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24168 PyObject *resultobj = 0;
24169 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24170 bool result;
24171 void *argp1 = 0 ;
24172 int res1 = 0 ;
24173 PyObject *swig_obj[1] ;
24174
24175 if (!args) SWIG_fail;
24176 swig_obj[0] = args;
24177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24178 if (!SWIG_IsOK(res1)) {
24179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24180 }
24181 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24182 {
24183 PyThreadState* __tstate = wxPyBeginAllowThreads();
24184 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24185 wxPyEndAllowThreads(__tstate);
24186 if (PyErr_Occurred()) SWIG_fail;
24187 }
24188 {
24189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24190 }
24191 return resultobj;
24192 fail:
24193 return NULL;
24194 }
24195
24196
24197 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24198 PyObject *resultobj = 0;
24199 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24200 bool arg2 ;
24201 void *argp1 = 0 ;
24202 int res1 = 0 ;
24203 bool val2 ;
24204 int ecode2 = 0 ;
24205 PyObject * obj0 = 0 ;
24206 PyObject * obj1 = 0 ;
24207 char * kwnames[] = {
24208 (char *) "self",(char *) "canVeto", NULL
24209 };
24210
24211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24213 if (!SWIG_IsOK(res1)) {
24214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24215 }
24216 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24217 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24218 if (!SWIG_IsOK(ecode2)) {
24219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24220 }
24221 arg2 = static_cast< bool >(val2);
24222 {
24223 PyThreadState* __tstate = wxPyBeginAllowThreads();
24224 (arg1)->SetCanVeto(arg2);
24225 wxPyEndAllowThreads(__tstate);
24226 if (PyErr_Occurred()) SWIG_fail;
24227 }
24228 resultobj = SWIG_Py_Void();
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24236 PyObject *resultobj = 0;
24237 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24238 bool result;
24239 void *argp1 = 0 ;
24240 int res1 = 0 ;
24241 PyObject *swig_obj[1] ;
24242
24243 if (!args) SWIG_fail;
24244 swig_obj[0] = args;
24245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24246 if (!SWIG_IsOK(res1)) {
24247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24248 }
24249 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24250 {
24251 PyThreadState* __tstate = wxPyBeginAllowThreads();
24252 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24253 wxPyEndAllowThreads(__tstate);
24254 if (PyErr_Occurred()) SWIG_fail;
24255 }
24256 {
24257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24258 }
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *obj;
24267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24268 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24269 return SWIG_Py_Void();
24270 }
24271
24272 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24273 return SWIG_Python_InitShadowInstance(args);
24274 }
24275
24276 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24277 PyObject *resultobj = 0;
24278 int arg1 = (int) 0 ;
24279 bool arg2 = (bool) false ;
24280 wxShowEvent *result = 0 ;
24281 int val1 ;
24282 int ecode1 = 0 ;
24283 bool val2 ;
24284 int ecode2 = 0 ;
24285 PyObject * obj0 = 0 ;
24286 PyObject * obj1 = 0 ;
24287 char * kwnames[] = {
24288 (char *) "winid",(char *) "show", NULL
24289 };
24290
24291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24292 if (obj0) {
24293 ecode1 = SWIG_AsVal_int(obj0, &val1);
24294 if (!SWIG_IsOK(ecode1)) {
24295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24296 }
24297 arg1 = static_cast< int >(val1);
24298 }
24299 if (obj1) {
24300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24301 if (!SWIG_IsOK(ecode2)) {
24302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24303 }
24304 arg2 = static_cast< bool >(val2);
24305 }
24306 {
24307 PyThreadState* __tstate = wxPyBeginAllowThreads();
24308 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24320 PyObject *resultobj = 0;
24321 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24322 bool arg2 ;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 bool val2 ;
24326 int ecode2 = 0 ;
24327 PyObject * obj0 = 0 ;
24328 PyObject * obj1 = 0 ;
24329 char * kwnames[] = {
24330 (char *) "self",(char *) "show", NULL
24331 };
24332
24333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24337 }
24338 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24339 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24340 if (!SWIG_IsOK(ecode2)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24342 }
24343 arg2 = static_cast< bool >(val2);
24344 {
24345 PyThreadState* __tstate = wxPyBeginAllowThreads();
24346 (arg1)->SetShow(arg2);
24347 wxPyEndAllowThreads(__tstate);
24348 if (PyErr_Occurred()) SWIG_fail;
24349 }
24350 resultobj = SWIG_Py_Void();
24351 return resultobj;
24352 fail:
24353 return NULL;
24354 }
24355
24356
24357 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24358 PyObject *resultobj = 0;
24359 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24360 bool result;
24361 void *argp1 = 0 ;
24362 int res1 = 0 ;
24363 PyObject *swig_obj[1] ;
24364
24365 if (!args) SWIG_fail;
24366 swig_obj[0] = args;
24367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24368 if (!SWIG_IsOK(res1)) {
24369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24370 }
24371 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 {
24379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24380 }
24381 return resultobj;
24382 fail:
24383 return NULL;
24384 }
24385
24386
24387 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24388 PyObject *obj;
24389 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24390 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24391 return SWIG_Py_Void();
24392 }
24393
24394 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24395 return SWIG_Python_InitShadowInstance(args);
24396 }
24397
24398 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24399 PyObject *resultobj = 0;
24400 int arg1 = (int) 0 ;
24401 bool arg2 = (bool) true ;
24402 wxIconizeEvent *result = 0 ;
24403 int val1 ;
24404 int ecode1 = 0 ;
24405 bool val2 ;
24406 int ecode2 = 0 ;
24407 PyObject * obj0 = 0 ;
24408 PyObject * obj1 = 0 ;
24409 char * kwnames[] = {
24410 (char *) "id",(char *) "iconized", NULL
24411 };
24412
24413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24414 if (obj0) {
24415 ecode1 = SWIG_AsVal_int(obj0, &val1);
24416 if (!SWIG_IsOK(ecode1)) {
24417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24418 }
24419 arg1 = static_cast< int >(val1);
24420 }
24421 if (obj1) {
24422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24423 if (!SWIG_IsOK(ecode2)) {
24424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24425 }
24426 arg2 = static_cast< bool >(val2);
24427 }
24428 {
24429 PyThreadState* __tstate = wxPyBeginAllowThreads();
24430 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24442 PyObject *resultobj = 0;
24443 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24444 bool result;
24445 void *argp1 = 0 ;
24446 int res1 = 0 ;
24447 PyObject *swig_obj[1] ;
24448
24449 if (!args) SWIG_fail;
24450 swig_obj[0] = args;
24451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24452 if (!SWIG_IsOK(res1)) {
24453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24454 }
24455 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24456 {
24457 PyThreadState* __tstate = wxPyBeginAllowThreads();
24458 result = (bool)(arg1)->Iconized();
24459 wxPyEndAllowThreads(__tstate);
24460 if (PyErr_Occurred()) SWIG_fail;
24461 }
24462 {
24463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24464 }
24465 return resultobj;
24466 fail:
24467 return NULL;
24468 }
24469
24470
24471 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24472 PyObject *obj;
24473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24474 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24475 return SWIG_Py_Void();
24476 }
24477
24478 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24479 return SWIG_Python_InitShadowInstance(args);
24480 }
24481
24482 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj = 0;
24484 int arg1 = (int) 0 ;
24485 wxMaximizeEvent *result = 0 ;
24486 int val1 ;
24487 int ecode1 = 0 ;
24488 PyObject * obj0 = 0 ;
24489 char * kwnames[] = {
24490 (char *) "id", NULL
24491 };
24492
24493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24494 if (obj0) {
24495 ecode1 = SWIG_AsVal_int(obj0, &val1);
24496 if (!SWIG_IsOK(ecode1)) {
24497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24498 }
24499 arg1 = static_cast< int >(val1);
24500 }
24501 {
24502 PyThreadState* __tstate = wxPyBeginAllowThreads();
24503 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24515 PyObject *obj;
24516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24517 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24518 return SWIG_Py_Void();
24519 }
24520
24521 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24522 return SWIG_Python_InitShadowInstance(args);
24523 }
24524
24525 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24526 PyObject *resultobj = 0;
24527 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24528 wxPoint result;
24529 void *argp1 = 0 ;
24530 int res1 = 0 ;
24531 PyObject *swig_obj[1] ;
24532
24533 if (!args) SWIG_fail;
24534 swig_obj[0] = args;
24535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24536 if (!SWIG_IsOK(res1)) {
24537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24538 }
24539 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24540 {
24541 PyThreadState* __tstate = wxPyBeginAllowThreads();
24542 result = (arg1)->GetPosition();
24543 wxPyEndAllowThreads(__tstate);
24544 if (PyErr_Occurred()) SWIG_fail;
24545 }
24546 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24554 PyObject *resultobj = 0;
24555 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24556 int result;
24557 void *argp1 = 0 ;
24558 int res1 = 0 ;
24559 PyObject *swig_obj[1] ;
24560
24561 if (!args) SWIG_fail;
24562 swig_obj[0] = args;
24563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24564 if (!SWIG_IsOK(res1)) {
24565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24566 }
24567 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24568 {
24569 PyThreadState* __tstate = wxPyBeginAllowThreads();
24570 result = (int)(arg1)->GetNumberOfFiles();
24571 wxPyEndAllowThreads(__tstate);
24572 if (PyErr_Occurred()) SWIG_fail;
24573 }
24574 resultobj = SWIG_From_int(static_cast< int >(result));
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24584 PyObject *result = 0 ;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 PyObject *swig_obj[1] ;
24588
24589 if (!args) SWIG_fail;
24590 swig_obj[0] = args;
24591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24594 }
24595 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 resultobj = result;
24603 return resultobj;
24604 fail:
24605 return NULL;
24606 }
24607
24608
24609 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24610 PyObject *obj;
24611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24612 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24613 return SWIG_Py_Void();
24614 }
24615
24616 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24617 PyObject *resultobj = 0;
24618 int arg1 = (int) 0 ;
24619 wxUpdateUIEvent *result = 0 ;
24620 int val1 ;
24621 int ecode1 = 0 ;
24622 PyObject * obj0 = 0 ;
24623 char * kwnames[] = {
24624 (char *) "commandId", NULL
24625 };
24626
24627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24628 if (obj0) {
24629 ecode1 = SWIG_AsVal_int(obj0, &val1);
24630 if (!SWIG_IsOK(ecode1)) {
24631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24632 }
24633 arg1 = static_cast< int >(val1);
24634 }
24635 {
24636 PyThreadState* __tstate = wxPyBeginAllowThreads();
24637 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24649 PyObject *resultobj = 0;
24650 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24651 bool result;
24652 void *argp1 = 0 ;
24653 int res1 = 0 ;
24654 PyObject *swig_obj[1] ;
24655
24656 if (!args) SWIG_fail;
24657 swig_obj[0] = args;
24658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24659 if (!SWIG_IsOK(res1)) {
24660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24661 }
24662 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24663 {
24664 PyThreadState* __tstate = wxPyBeginAllowThreads();
24665 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 {
24670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24671 }
24672 return resultobj;
24673 fail:
24674 return NULL;
24675 }
24676
24677
24678 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24679 PyObject *resultobj = 0;
24680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24681 bool result;
24682 void *argp1 = 0 ;
24683 int res1 = 0 ;
24684 PyObject *swig_obj[1] ;
24685
24686 if (!args) SWIG_fail;
24687 swig_obj[0] = args;
24688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24689 if (!SWIG_IsOK(res1)) {
24690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24691 }
24692 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24693 {
24694 PyThreadState* __tstate = wxPyBeginAllowThreads();
24695 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24696 wxPyEndAllowThreads(__tstate);
24697 if (PyErr_Occurred()) SWIG_fail;
24698 }
24699 {
24700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24701 }
24702 return resultobj;
24703 fail:
24704 return NULL;
24705 }
24706
24707
24708 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24709 PyObject *resultobj = 0;
24710 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24711 bool result;
24712 void *argp1 = 0 ;
24713 int res1 = 0 ;
24714 PyObject *swig_obj[1] ;
24715
24716 if (!args) SWIG_fail;
24717 swig_obj[0] = args;
24718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24719 if (!SWIG_IsOK(res1)) {
24720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24721 }
24722 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24726 wxPyEndAllowThreads(__tstate);
24727 if (PyErr_Occurred()) SWIG_fail;
24728 }
24729 {
24730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24731 }
24732 return resultobj;
24733 fail:
24734 return NULL;
24735 }
24736
24737
24738 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24739 PyObject *resultobj = 0;
24740 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24741 wxString result;
24742 void *argp1 = 0 ;
24743 int res1 = 0 ;
24744 PyObject *swig_obj[1] ;
24745
24746 if (!args) SWIG_fail;
24747 swig_obj[0] = args;
24748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24749 if (!SWIG_IsOK(res1)) {
24750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24751 }
24752 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24753 {
24754 PyThreadState* __tstate = wxPyBeginAllowThreads();
24755 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24756 wxPyEndAllowThreads(__tstate);
24757 if (PyErr_Occurred()) SWIG_fail;
24758 }
24759 {
24760 #if wxUSE_UNICODE
24761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24762 #else
24763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24764 #endif
24765 }
24766 return resultobj;
24767 fail:
24768 return NULL;
24769 }
24770
24771
24772 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24773 PyObject *resultobj = 0;
24774 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24775 bool result;
24776 void *argp1 = 0 ;
24777 int res1 = 0 ;
24778 PyObject *swig_obj[1] ;
24779
24780 if (!args) SWIG_fail;
24781 swig_obj[0] = args;
24782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24783 if (!SWIG_IsOK(res1)) {
24784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24785 }
24786 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24790 wxPyEndAllowThreads(__tstate);
24791 if (PyErr_Occurred()) SWIG_fail;
24792 }
24793 {
24794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24795 }
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24803 PyObject *resultobj = 0;
24804 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24805 bool result;
24806 void *argp1 = 0 ;
24807 int res1 = 0 ;
24808 PyObject *swig_obj[1] ;
24809
24810 if (!args) SWIG_fail;
24811 swig_obj[0] = args;
24812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24813 if (!SWIG_IsOK(res1)) {
24814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24815 }
24816 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24817 {
24818 PyThreadState* __tstate = wxPyBeginAllowThreads();
24819 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24820 wxPyEndAllowThreads(__tstate);
24821 if (PyErr_Occurred()) SWIG_fail;
24822 }
24823 {
24824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24825 }
24826 return resultobj;
24827 fail:
24828 return NULL;
24829 }
24830
24831
24832 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24833 PyObject *resultobj = 0;
24834 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24835 bool result;
24836 void *argp1 = 0 ;
24837 int res1 = 0 ;
24838 PyObject *swig_obj[1] ;
24839
24840 if (!args) SWIG_fail;
24841 swig_obj[0] = args;
24842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24843 if (!SWIG_IsOK(res1)) {
24844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24845 }
24846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24847 {
24848 PyThreadState* __tstate = wxPyBeginAllowThreads();
24849 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24850 wxPyEndAllowThreads(__tstate);
24851 if (PyErr_Occurred()) SWIG_fail;
24852 }
24853 {
24854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24855 }
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *resultobj = 0;
24864 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24865 bool result;
24866 void *argp1 = 0 ;
24867 int res1 = 0 ;
24868 PyObject *swig_obj[1] ;
24869
24870 if (!args) SWIG_fail;
24871 swig_obj[0] = args;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24875 }
24876 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24877 {
24878 PyThreadState* __tstate = wxPyBeginAllowThreads();
24879 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24880 wxPyEndAllowThreads(__tstate);
24881 if (PyErr_Occurred()) SWIG_fail;
24882 }
24883 {
24884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24885 }
24886 return resultobj;
24887 fail:
24888 return NULL;
24889 }
24890
24891
24892 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24893 PyObject *resultobj = 0;
24894 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24895 bool arg2 ;
24896 void *argp1 = 0 ;
24897 int res1 = 0 ;
24898 bool val2 ;
24899 int ecode2 = 0 ;
24900 PyObject * obj0 = 0 ;
24901 PyObject * obj1 = 0 ;
24902 char * kwnames[] = {
24903 (char *) "self",(char *) "check", NULL
24904 };
24905
24906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24908 if (!SWIG_IsOK(res1)) {
24909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24910 }
24911 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24912 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24913 if (!SWIG_IsOK(ecode2)) {
24914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24915 }
24916 arg2 = static_cast< bool >(val2);
24917 {
24918 PyThreadState* __tstate = wxPyBeginAllowThreads();
24919 (arg1)->Check(arg2);
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 resultobj = SWIG_Py_Void();
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24933 bool arg2 ;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 bool val2 ;
24937 int ecode2 = 0 ;
24938 PyObject * obj0 = 0 ;
24939 PyObject * obj1 = 0 ;
24940 char * kwnames[] = {
24941 (char *) "self",(char *) "enable", NULL
24942 };
24943
24944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24946 if (!SWIG_IsOK(res1)) {
24947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24948 }
24949 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24950 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24951 if (!SWIG_IsOK(ecode2)) {
24952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24953 }
24954 arg2 = static_cast< bool >(val2);
24955 {
24956 PyThreadState* __tstate = wxPyBeginAllowThreads();
24957 (arg1)->Enable(arg2);
24958 wxPyEndAllowThreads(__tstate);
24959 if (PyErr_Occurred()) SWIG_fail;
24960 }
24961 resultobj = SWIG_Py_Void();
24962 return resultobj;
24963 fail:
24964 return NULL;
24965 }
24966
24967
24968 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24969 PyObject *resultobj = 0;
24970 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24971 bool arg2 ;
24972 void *argp1 = 0 ;
24973 int res1 = 0 ;
24974 bool val2 ;
24975 int ecode2 = 0 ;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 char * kwnames[] = {
24979 (char *) "self",(char *) "show", NULL
24980 };
24981
24982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24984 if (!SWIG_IsOK(res1)) {
24985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24986 }
24987 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24988 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24989 if (!SWIG_IsOK(ecode2)) {
24990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24991 }
24992 arg2 = static_cast< bool >(val2);
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 (arg1)->Show(arg2);
24996 wxPyEndAllowThreads(__tstate);
24997 if (PyErr_Occurred()) SWIG_fail;
24998 }
24999 resultobj = SWIG_Py_Void();
25000 return resultobj;
25001 fail:
25002 return NULL;
25003 }
25004
25005
25006 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25007 PyObject *resultobj = 0;
25008 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25009 wxString *arg2 = 0 ;
25010 void *argp1 = 0 ;
25011 int res1 = 0 ;
25012 bool temp2 = false ;
25013 PyObject * obj0 = 0 ;
25014 PyObject * obj1 = 0 ;
25015 char * kwnames[] = {
25016 (char *) "self",(char *) "text", NULL
25017 };
25018
25019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25021 if (!SWIG_IsOK(res1)) {
25022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25023 }
25024 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25025 {
25026 arg2 = wxString_in_helper(obj1);
25027 if (arg2 == NULL) SWIG_fail;
25028 temp2 = true;
25029 }
25030 {
25031 PyThreadState* __tstate = wxPyBeginAllowThreads();
25032 (arg1)->SetText((wxString const &)*arg2);
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 resultobj = SWIG_Py_Void();
25037 {
25038 if (temp2)
25039 delete arg2;
25040 }
25041 return resultobj;
25042 fail:
25043 {
25044 if (temp2)
25045 delete arg2;
25046 }
25047 return NULL;
25048 }
25049
25050
25051 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25052 PyObject *resultobj = 0;
25053 long arg1 ;
25054 long val1 ;
25055 int ecode1 = 0 ;
25056 PyObject * obj0 = 0 ;
25057 char * kwnames[] = {
25058 (char *) "updateInterval", NULL
25059 };
25060
25061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25062 ecode1 = SWIG_AsVal_long(obj0, &val1);
25063 if (!SWIG_IsOK(ecode1)) {
25064 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25065 }
25066 arg1 = static_cast< long >(val1);
25067 {
25068 PyThreadState* __tstate = wxPyBeginAllowThreads();
25069 wxUpdateUIEvent::SetUpdateInterval(arg1);
25070 wxPyEndAllowThreads(__tstate);
25071 if (PyErr_Occurred()) SWIG_fail;
25072 }
25073 resultobj = SWIG_Py_Void();
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25081 PyObject *resultobj = 0;
25082 long result;
25083
25084 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25085 {
25086 PyThreadState* __tstate = wxPyBeginAllowThreads();
25087 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25088 wxPyEndAllowThreads(__tstate);
25089 if (PyErr_Occurred()) SWIG_fail;
25090 }
25091 resultobj = SWIG_From_long(static_cast< long >(result));
25092 return resultobj;
25093 fail:
25094 return NULL;
25095 }
25096
25097
25098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25099 PyObject *resultobj = 0;
25100 wxWindow *arg1 = (wxWindow *) 0 ;
25101 bool result;
25102 void *argp1 = 0 ;
25103 int res1 = 0 ;
25104 PyObject * obj0 = 0 ;
25105 char * kwnames[] = {
25106 (char *) "win", NULL
25107 };
25108
25109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25111 if (!SWIG_IsOK(res1)) {
25112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25113 }
25114 arg1 = reinterpret_cast< wxWindow * >(argp1);
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 {
25122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25123 }
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131 PyObject *resultobj = 0;
25132
25133 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25134 {
25135 PyThreadState* __tstate = wxPyBeginAllowThreads();
25136 wxUpdateUIEvent::ResetUpdateTime();
25137 wxPyEndAllowThreads(__tstate);
25138 if (PyErr_Occurred()) SWIG_fail;
25139 }
25140 resultobj = SWIG_Py_Void();
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25148 PyObject *resultobj = 0;
25149 wxUpdateUIMode arg1 ;
25150 int val1 ;
25151 int ecode1 = 0 ;
25152 PyObject * obj0 = 0 ;
25153 char * kwnames[] = {
25154 (char *) "mode", NULL
25155 };
25156
25157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25158 ecode1 = SWIG_AsVal_int(obj0, &val1);
25159 if (!SWIG_IsOK(ecode1)) {
25160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25161 }
25162 arg1 = static_cast< wxUpdateUIMode >(val1);
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 wxUpdateUIEvent::SetMode(arg1);
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 resultobj = SWIG_Py_Void();
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25177 PyObject *resultobj = 0;
25178 wxUpdateUIMode result;
25179
25180 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25181 {
25182 PyThreadState* __tstate = wxPyBeginAllowThreads();
25183 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25184 wxPyEndAllowThreads(__tstate);
25185 if (PyErr_Occurred()) SWIG_fail;
25186 }
25187 resultobj = SWIG_From_int(static_cast< int >(result));
25188 return resultobj;
25189 fail:
25190 return NULL;
25191 }
25192
25193
25194 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25195 PyObject *obj;
25196 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25197 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25198 return SWIG_Py_Void();
25199 }
25200
25201 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25202 return SWIG_Python_InitShadowInstance(args);
25203 }
25204
25205 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25206 PyObject *resultobj = 0;
25207 wxSysColourChangedEvent *result = 0 ;
25208
25209 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25213 wxPyEndAllowThreads(__tstate);
25214 if (PyErr_Occurred()) SWIG_fail;
25215 }
25216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25217 return resultobj;
25218 fail:
25219 return NULL;
25220 }
25221
25222
25223 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25224 PyObject *obj;
25225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25226 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25227 return SWIG_Py_Void();
25228 }
25229
25230 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25231 return SWIG_Python_InitShadowInstance(args);
25232 }
25233
25234 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25235 PyObject *resultobj = 0;
25236 int arg1 = (int) 0 ;
25237 wxWindow *arg2 = (wxWindow *) NULL ;
25238 wxMouseCaptureChangedEvent *result = 0 ;
25239 int val1 ;
25240 int ecode1 = 0 ;
25241 void *argp2 = 0 ;
25242 int res2 = 0 ;
25243 PyObject * obj0 = 0 ;
25244 PyObject * obj1 = 0 ;
25245 char * kwnames[] = {
25246 (char *) "winid",(char *) "gainedCapture", NULL
25247 };
25248
25249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25250 if (obj0) {
25251 ecode1 = SWIG_AsVal_int(obj0, &val1);
25252 if (!SWIG_IsOK(ecode1)) {
25253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25254 }
25255 arg1 = static_cast< int >(val1);
25256 }
25257 if (obj1) {
25258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25259 if (!SWIG_IsOK(res2)) {
25260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25261 }
25262 arg2 = reinterpret_cast< wxWindow * >(argp2);
25263 }
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25267 wxPyEndAllowThreads(__tstate);
25268 if (PyErr_Occurred()) SWIG_fail;
25269 }
25270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25271 return resultobj;
25272 fail:
25273 return NULL;
25274 }
25275
25276
25277 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25278 PyObject *resultobj = 0;
25279 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25280 wxWindow *result = 0 ;
25281 void *argp1 = 0 ;
25282 int res1 = 0 ;
25283 PyObject *swig_obj[1] ;
25284
25285 if (!args) SWIG_fail;
25286 swig_obj[0] = args;
25287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25288 if (!SWIG_IsOK(res1)) {
25289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25290 }
25291 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25292 {
25293 PyThreadState* __tstate = wxPyBeginAllowThreads();
25294 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25295 wxPyEndAllowThreads(__tstate);
25296 if (PyErr_Occurred()) SWIG_fail;
25297 }
25298 {
25299 resultobj = wxPyMake_wxObject(result, (bool)0);
25300 }
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25308 PyObject *obj;
25309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25310 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25311 return SWIG_Py_Void();
25312 }
25313
25314 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25315 return SWIG_Python_InitShadowInstance(args);
25316 }
25317
25318 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25319 PyObject *resultobj = 0;
25320 wxDisplayChangedEvent *result = 0 ;
25321
25322 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25330 return resultobj;
25331 fail:
25332 return NULL;
25333 }
25334
25335
25336 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25337 PyObject *obj;
25338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25339 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25340 return SWIG_Py_Void();
25341 }
25342
25343 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25344 return SWIG_Python_InitShadowInstance(args);
25345 }
25346
25347 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25348 PyObject *resultobj = 0;
25349 int arg1 = (int) 0 ;
25350 wxPaletteChangedEvent *result = 0 ;
25351 int val1 ;
25352 int ecode1 = 0 ;
25353 PyObject * obj0 = 0 ;
25354 char * kwnames[] = {
25355 (char *) "id", NULL
25356 };
25357
25358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25359 if (obj0) {
25360 ecode1 = SWIG_AsVal_int(obj0, &val1);
25361 if (!SWIG_IsOK(ecode1)) {
25362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25363 }
25364 arg1 = static_cast< int >(val1);
25365 }
25366 {
25367 PyThreadState* __tstate = wxPyBeginAllowThreads();
25368 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25380 PyObject *resultobj = 0;
25381 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25382 wxWindow *arg2 = (wxWindow *) 0 ;
25383 void *argp1 = 0 ;
25384 int res1 = 0 ;
25385 void *argp2 = 0 ;
25386 int res2 = 0 ;
25387 PyObject * obj0 = 0 ;
25388 PyObject * obj1 = 0 ;
25389 char * kwnames[] = {
25390 (char *) "self",(char *) "win", NULL
25391 };
25392
25393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25395 if (!SWIG_IsOK(res1)) {
25396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25397 }
25398 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25400 if (!SWIG_IsOK(res2)) {
25401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25402 }
25403 arg2 = reinterpret_cast< wxWindow * >(argp2);
25404 {
25405 PyThreadState* __tstate = wxPyBeginAllowThreads();
25406 (arg1)->SetChangedWindow(arg2);
25407 wxPyEndAllowThreads(__tstate);
25408 if (PyErr_Occurred()) SWIG_fail;
25409 }
25410 resultobj = SWIG_Py_Void();
25411 return resultobj;
25412 fail:
25413 return NULL;
25414 }
25415
25416
25417 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25418 PyObject *resultobj = 0;
25419 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25420 wxWindow *result = 0 ;
25421 void *argp1 = 0 ;
25422 int res1 = 0 ;
25423 PyObject *swig_obj[1] ;
25424
25425 if (!args) SWIG_fail;
25426 swig_obj[0] = args;
25427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25428 if (!SWIG_IsOK(res1)) {
25429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25430 }
25431 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = (wxWindow *)(arg1)->GetChangedWindow();
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 {
25439 resultobj = wxPyMake_wxObject(result, (bool)0);
25440 }
25441 return resultobj;
25442 fail:
25443 return NULL;
25444 }
25445
25446
25447 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25448 PyObject *obj;
25449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25450 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25451 return SWIG_Py_Void();
25452 }
25453
25454 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25455 return SWIG_Python_InitShadowInstance(args);
25456 }
25457
25458 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25459 PyObject *resultobj = 0;
25460 int arg1 = (int) 0 ;
25461 wxQueryNewPaletteEvent *result = 0 ;
25462 int val1 ;
25463 int ecode1 = 0 ;
25464 PyObject * obj0 = 0 ;
25465 char * kwnames[] = {
25466 (char *) "winid", NULL
25467 };
25468
25469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25470 if (obj0) {
25471 ecode1 = SWIG_AsVal_int(obj0, &val1);
25472 if (!SWIG_IsOK(ecode1)) {
25473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25474 }
25475 arg1 = static_cast< int >(val1);
25476 }
25477 {
25478 PyThreadState* __tstate = wxPyBeginAllowThreads();
25479 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25480 wxPyEndAllowThreads(__tstate);
25481 if (PyErr_Occurred()) SWIG_fail;
25482 }
25483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25484 return resultobj;
25485 fail:
25486 return NULL;
25487 }
25488
25489
25490 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25491 PyObject *resultobj = 0;
25492 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25493 bool arg2 ;
25494 void *argp1 = 0 ;
25495 int res1 = 0 ;
25496 bool val2 ;
25497 int ecode2 = 0 ;
25498 PyObject * obj0 = 0 ;
25499 PyObject * obj1 = 0 ;
25500 char * kwnames[] = {
25501 (char *) "self",(char *) "realized", NULL
25502 };
25503
25504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25506 if (!SWIG_IsOK(res1)) {
25507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25508 }
25509 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25511 if (!SWIG_IsOK(ecode2)) {
25512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25513 }
25514 arg2 = static_cast< bool >(val2);
25515 {
25516 PyThreadState* __tstate = wxPyBeginAllowThreads();
25517 (arg1)->SetPaletteRealized(arg2);
25518 wxPyEndAllowThreads(__tstate);
25519 if (PyErr_Occurred()) SWIG_fail;
25520 }
25521 resultobj = SWIG_Py_Void();
25522 return resultobj;
25523 fail:
25524 return NULL;
25525 }
25526
25527
25528 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 PyObject *resultobj = 0;
25530 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25531 bool result;
25532 void *argp1 = 0 ;
25533 int res1 = 0 ;
25534 PyObject *swig_obj[1] ;
25535
25536 if (!args) SWIG_fail;
25537 swig_obj[0] = args;
25538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25539 if (!SWIG_IsOK(res1)) {
25540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25541 }
25542 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 {
25550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25551 }
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *obj;
25560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25561 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25562 return SWIG_Py_Void();
25563 }
25564
25565 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 return SWIG_Python_InitShadowInstance(args);
25567 }
25568
25569 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25570 PyObject *resultobj = 0;
25571 wxNavigationKeyEvent *result = 0 ;
25572
25573 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25577 wxPyEndAllowThreads(__tstate);
25578 if (PyErr_Occurred()) SWIG_fail;
25579 }
25580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *resultobj = 0;
25589 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25590 bool result;
25591 void *argp1 = 0 ;
25592 int res1 = 0 ;
25593 PyObject *swig_obj[1] ;
25594
25595 if (!args) SWIG_fail;
25596 swig_obj[0] = args;
25597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25598 if (!SWIG_IsOK(res1)) {
25599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25600 }
25601 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25602 {
25603 PyThreadState* __tstate = wxPyBeginAllowThreads();
25604 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25605 wxPyEndAllowThreads(__tstate);
25606 if (PyErr_Occurred()) SWIG_fail;
25607 }
25608 {
25609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25610 }
25611 return resultobj;
25612 fail:
25613 return NULL;
25614 }
25615
25616
25617 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25618 PyObject *resultobj = 0;
25619 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25620 bool arg2 ;
25621 void *argp1 = 0 ;
25622 int res1 = 0 ;
25623 bool val2 ;
25624 int ecode2 = 0 ;
25625 PyObject * obj0 = 0 ;
25626 PyObject * obj1 = 0 ;
25627 char * kwnames[] = {
25628 (char *) "self",(char *) "forward", NULL
25629 };
25630
25631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25633 if (!SWIG_IsOK(res1)) {
25634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25635 }
25636 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25637 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25638 if (!SWIG_IsOK(ecode2)) {
25639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25640 }
25641 arg2 = static_cast< bool >(val2);
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 (arg1)->SetDirection(arg2);
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 resultobj = SWIG_Py_Void();
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656 PyObject *resultobj = 0;
25657 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25658 bool result;
25659 void *argp1 = 0 ;
25660 int res1 = 0 ;
25661 PyObject *swig_obj[1] ;
25662
25663 if (!args) SWIG_fail;
25664 swig_obj[0] = args;
25665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25666 if (!SWIG_IsOK(res1)) {
25667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25668 }
25669 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25670 {
25671 PyThreadState* __tstate = wxPyBeginAllowThreads();
25672 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25673 wxPyEndAllowThreads(__tstate);
25674 if (PyErr_Occurred()) SWIG_fail;
25675 }
25676 {
25677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25678 }
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25686 PyObject *resultobj = 0;
25687 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25688 bool arg2 ;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 bool val2 ;
25692 int ecode2 = 0 ;
25693 PyObject * obj0 = 0 ;
25694 PyObject * obj1 = 0 ;
25695 char * kwnames[] = {
25696 (char *) "self",(char *) "ischange", NULL
25697 };
25698
25699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25701 if (!SWIG_IsOK(res1)) {
25702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25703 }
25704 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25705 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25706 if (!SWIG_IsOK(ecode2)) {
25707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25708 }
25709 arg2 = static_cast< bool >(val2);
25710 {
25711 PyThreadState* __tstate = wxPyBeginAllowThreads();
25712 (arg1)->SetWindowChange(arg2);
25713 wxPyEndAllowThreads(__tstate);
25714 if (PyErr_Occurred()) SWIG_fail;
25715 }
25716 resultobj = SWIG_Py_Void();
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25724 PyObject *resultobj = 0;
25725 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25726 bool result;
25727 void *argp1 = 0 ;
25728 int res1 = 0 ;
25729 PyObject *swig_obj[1] ;
25730
25731 if (!args) SWIG_fail;
25732 swig_obj[0] = args;
25733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25754 PyObject *resultobj = 0;
25755 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25756 bool arg2 ;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 bool val2 ;
25760 int ecode2 = 0 ;
25761 PyObject * obj0 = 0 ;
25762 PyObject * obj1 = 0 ;
25763 char * kwnames[] = {
25764 (char *) "self",(char *) "bIs", NULL
25765 };
25766
25767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25769 if (!SWIG_IsOK(res1)) {
25770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25771 }
25772 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25773 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25774 if (!SWIG_IsOK(ecode2)) {
25775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25776 }
25777 arg2 = static_cast< bool >(val2);
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 (arg1)->SetFromTab(arg2);
25781 wxPyEndAllowThreads(__tstate);
25782 if (PyErr_Occurred()) SWIG_fail;
25783 }
25784 resultobj = SWIG_Py_Void();
25785 return resultobj;
25786 fail:
25787 return NULL;
25788 }
25789
25790
25791 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25792 PyObject *resultobj = 0;
25793 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25794 long arg2 ;
25795 void *argp1 = 0 ;
25796 int res1 = 0 ;
25797 long val2 ;
25798 int ecode2 = 0 ;
25799 PyObject * obj0 = 0 ;
25800 PyObject * obj1 = 0 ;
25801 char * kwnames[] = {
25802 (char *) "self",(char *) "flags", NULL
25803 };
25804
25805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25807 if (!SWIG_IsOK(res1)) {
25808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25809 }
25810 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25811 ecode2 = SWIG_AsVal_long(obj1, &val2);
25812 if (!SWIG_IsOK(ecode2)) {
25813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25814 }
25815 arg2 = static_cast< long >(val2);
25816 {
25817 PyThreadState* __tstate = wxPyBeginAllowThreads();
25818 (arg1)->SetFlags(arg2);
25819 wxPyEndAllowThreads(__tstate);
25820 if (PyErr_Occurred()) SWIG_fail;
25821 }
25822 resultobj = SWIG_Py_Void();
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25830 PyObject *resultobj = 0;
25831 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25832 wxWindow *result = 0 ;
25833 void *argp1 = 0 ;
25834 int res1 = 0 ;
25835 PyObject *swig_obj[1] ;
25836
25837 if (!args) SWIG_fail;
25838 swig_obj[0] = args;
25839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25840 if (!SWIG_IsOK(res1)) {
25841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25842 }
25843 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25844 {
25845 PyThreadState* __tstate = wxPyBeginAllowThreads();
25846 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25847 wxPyEndAllowThreads(__tstate);
25848 if (PyErr_Occurred()) SWIG_fail;
25849 }
25850 {
25851 resultobj = wxPyMake_wxObject(result, (bool)0);
25852 }
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25860 PyObject *resultobj = 0;
25861 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25862 wxWindow *arg2 = (wxWindow *) 0 ;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 void *argp2 = 0 ;
25866 int res2 = 0 ;
25867 PyObject * obj0 = 0 ;
25868 PyObject * obj1 = 0 ;
25869 char * kwnames[] = {
25870 (char *) "self",(char *) "win", NULL
25871 };
25872
25873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25875 if (!SWIG_IsOK(res1)) {
25876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25877 }
25878 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25880 if (!SWIG_IsOK(res2)) {
25881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25882 }
25883 arg2 = reinterpret_cast< wxWindow * >(argp2);
25884 {
25885 PyThreadState* __tstate = wxPyBeginAllowThreads();
25886 (arg1)->SetCurrentFocus(arg2);
25887 wxPyEndAllowThreads(__tstate);
25888 if (PyErr_Occurred()) SWIG_fail;
25889 }
25890 resultobj = SWIG_Py_Void();
25891 return resultobj;
25892 fail:
25893 return NULL;
25894 }
25895
25896
25897 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25898 PyObject *obj;
25899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25900 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25901 return SWIG_Py_Void();
25902 }
25903
25904 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25905 return SWIG_Python_InitShadowInstance(args);
25906 }
25907
25908 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25909 PyObject *resultobj = 0;
25910 wxWindow *arg1 = (wxWindow *) NULL ;
25911 wxWindowCreateEvent *result = 0 ;
25912 void *argp1 = 0 ;
25913 int res1 = 0 ;
25914 PyObject * obj0 = 0 ;
25915 char * kwnames[] = {
25916 (char *) "win", NULL
25917 };
25918
25919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25920 if (obj0) {
25921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25922 if (!SWIG_IsOK(res1)) {
25923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25924 }
25925 arg1 = reinterpret_cast< wxWindow * >(argp1);
25926 }
25927 {
25928 PyThreadState* __tstate = wxPyBeginAllowThreads();
25929 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25930 wxPyEndAllowThreads(__tstate);
25931 if (PyErr_Occurred()) SWIG_fail;
25932 }
25933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25934 return resultobj;
25935 fail:
25936 return NULL;
25937 }
25938
25939
25940 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25941 PyObject *resultobj = 0;
25942 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25943 wxWindow *result = 0 ;
25944 void *argp1 = 0 ;
25945 int res1 = 0 ;
25946 PyObject *swig_obj[1] ;
25947
25948 if (!args) SWIG_fail;
25949 swig_obj[0] = args;
25950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25951 if (!SWIG_IsOK(res1)) {
25952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25953 }
25954 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25955 {
25956 PyThreadState* __tstate = wxPyBeginAllowThreads();
25957 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25958 wxPyEndAllowThreads(__tstate);
25959 if (PyErr_Occurred()) SWIG_fail;
25960 }
25961 {
25962 resultobj = wxPyMake_wxObject(result, (bool)0);
25963 }
25964 return resultobj;
25965 fail:
25966 return NULL;
25967 }
25968
25969
25970 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25971 PyObject *obj;
25972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25973 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25974 return SWIG_Py_Void();
25975 }
25976
25977 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25978 return SWIG_Python_InitShadowInstance(args);
25979 }
25980
25981 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25982 PyObject *resultobj = 0;
25983 wxWindow *arg1 = (wxWindow *) NULL ;
25984 wxWindowDestroyEvent *result = 0 ;
25985 void *argp1 = 0 ;
25986 int res1 = 0 ;
25987 PyObject * obj0 = 0 ;
25988 char * kwnames[] = {
25989 (char *) "win", NULL
25990 };
25991
25992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25993 if (obj0) {
25994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25995 if (!SWIG_IsOK(res1)) {
25996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25997 }
25998 arg1 = reinterpret_cast< wxWindow * >(argp1);
25999 }
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26003 wxPyEndAllowThreads(__tstate);
26004 if (PyErr_Occurred()) SWIG_fail;
26005 }
26006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26007 return resultobj;
26008 fail:
26009 return NULL;
26010 }
26011
26012
26013 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26014 PyObject *resultobj = 0;
26015 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26016 wxWindow *result = 0 ;
26017 void *argp1 = 0 ;
26018 int res1 = 0 ;
26019 PyObject *swig_obj[1] ;
26020
26021 if (!args) SWIG_fail;
26022 swig_obj[0] = args;
26023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26024 if (!SWIG_IsOK(res1)) {
26025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26026 }
26027 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 {
26035 resultobj = wxPyMake_wxObject(result, (bool)0);
26036 }
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044 PyObject *obj;
26045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26046 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26047 return SWIG_Py_Void();
26048 }
26049
26050 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26051 return SWIG_Python_InitShadowInstance(args);
26052 }
26053
26054 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = 0;
26056 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26057 int arg2 = (int) 0 ;
26058 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26059 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26060 wxContextMenuEvent *result = 0 ;
26061 int val1 ;
26062 int ecode1 = 0 ;
26063 int val2 ;
26064 int ecode2 = 0 ;
26065 wxPoint temp3 ;
26066 PyObject * obj0 = 0 ;
26067 PyObject * obj1 = 0 ;
26068 PyObject * obj2 = 0 ;
26069 char * kwnames[] = {
26070 (char *) "type",(char *) "winid",(char *) "pt", NULL
26071 };
26072
26073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26074 if (obj0) {
26075 ecode1 = SWIG_AsVal_int(obj0, &val1);
26076 if (!SWIG_IsOK(ecode1)) {
26077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26078 }
26079 arg1 = static_cast< wxEventType >(val1);
26080 }
26081 if (obj1) {
26082 ecode2 = SWIG_AsVal_int(obj1, &val2);
26083 if (!SWIG_IsOK(ecode2)) {
26084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26085 }
26086 arg2 = static_cast< int >(val2);
26087 }
26088 if (obj2) {
26089 {
26090 arg3 = &temp3;
26091 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26092 }
26093 }
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *resultobj = 0;
26109 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26110 wxPoint *result = 0 ;
26111 void *argp1 = 0 ;
26112 int res1 = 0 ;
26113 PyObject *swig_obj[1] ;
26114
26115 if (!args) SWIG_fail;
26116 swig_obj[0] = args;
26117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26118 if (!SWIG_IsOK(res1)) {
26119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26120 }
26121 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26122 {
26123 PyThreadState* __tstate = wxPyBeginAllowThreads();
26124 {
26125 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26126 result = (wxPoint *) &_result_ref;
26127 }
26128 wxPyEndAllowThreads(__tstate);
26129 if (PyErr_Occurred()) SWIG_fail;
26130 }
26131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26132 return resultobj;
26133 fail:
26134 return NULL;
26135 }
26136
26137
26138 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26139 PyObject *resultobj = 0;
26140 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26141 wxPoint *arg2 = 0 ;
26142 void *argp1 = 0 ;
26143 int res1 = 0 ;
26144 wxPoint temp2 ;
26145 PyObject * obj0 = 0 ;
26146 PyObject * obj1 = 0 ;
26147 char * kwnames[] = {
26148 (char *) "self",(char *) "pos", NULL
26149 };
26150
26151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26153 if (!SWIG_IsOK(res1)) {
26154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26155 }
26156 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26157 {
26158 arg2 = &temp2;
26159 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26160 }
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 (arg1)->SetPosition((wxPoint const &)*arg2);
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_Py_Void();
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *obj;
26176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26177 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26178 return SWIG_Py_Void();
26179 }
26180
26181 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 return SWIG_Python_InitShadowInstance(args);
26183 }
26184
26185 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26186 PyObject *resultobj = 0;
26187 wxIdleEvent *result = 0 ;
26188
26189 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26190 {
26191 PyThreadState* __tstate = wxPyBeginAllowThreads();
26192 result = (wxIdleEvent *)new wxIdleEvent();
26193 wxPyEndAllowThreads(__tstate);
26194 if (PyErr_Occurred()) SWIG_fail;
26195 }
26196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26197 return resultobj;
26198 fail:
26199 return NULL;
26200 }
26201
26202
26203 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26204 PyObject *resultobj = 0;
26205 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26206 bool arg2 = (bool) true ;
26207 void *argp1 = 0 ;
26208 int res1 = 0 ;
26209 bool val2 ;
26210 int ecode2 = 0 ;
26211 PyObject * obj0 = 0 ;
26212 PyObject * obj1 = 0 ;
26213 char * kwnames[] = {
26214 (char *) "self",(char *) "needMore", NULL
26215 };
26216
26217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26219 if (!SWIG_IsOK(res1)) {
26220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26221 }
26222 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26223 if (obj1) {
26224 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26225 if (!SWIG_IsOK(ecode2)) {
26226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26227 }
26228 arg2 = static_cast< bool >(val2);
26229 }
26230 {
26231 PyThreadState* __tstate = wxPyBeginAllowThreads();
26232 (arg1)->RequestMore(arg2);
26233 wxPyEndAllowThreads(__tstate);
26234 if (PyErr_Occurred()) SWIG_fail;
26235 }
26236 resultobj = SWIG_Py_Void();
26237 return resultobj;
26238 fail:
26239 return NULL;
26240 }
26241
26242
26243 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26244 PyObject *resultobj = 0;
26245 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26246 bool result;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 PyObject *swig_obj[1] ;
26250
26251 if (!args) SWIG_fail;
26252 swig_obj[0] = args;
26253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26254 if (!SWIG_IsOK(res1)) {
26255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26256 }
26257 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 {
26265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26266 }
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26274 PyObject *resultobj = 0;
26275 wxIdleMode arg1 ;
26276 int val1 ;
26277 int ecode1 = 0 ;
26278 PyObject * obj0 = 0 ;
26279 char * kwnames[] = {
26280 (char *) "mode", NULL
26281 };
26282
26283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26284 ecode1 = SWIG_AsVal_int(obj0, &val1);
26285 if (!SWIG_IsOK(ecode1)) {
26286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26287 }
26288 arg1 = static_cast< wxIdleMode >(val1);
26289 {
26290 PyThreadState* __tstate = wxPyBeginAllowThreads();
26291 wxIdleEvent::SetMode(arg1);
26292 wxPyEndAllowThreads(__tstate);
26293 if (PyErr_Occurred()) SWIG_fail;
26294 }
26295 resultobj = SWIG_Py_Void();
26296 return resultobj;
26297 fail:
26298 return NULL;
26299 }
26300
26301
26302 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26303 PyObject *resultobj = 0;
26304 wxIdleMode result;
26305
26306 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26307 {
26308 PyThreadState* __tstate = wxPyBeginAllowThreads();
26309 result = (wxIdleMode)wxIdleEvent::GetMode();
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 resultobj = SWIG_From_int(static_cast< int >(result));
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26321 PyObject *resultobj = 0;
26322 wxWindow *arg1 = (wxWindow *) 0 ;
26323 bool result;
26324 void *argp1 = 0 ;
26325 int res1 = 0 ;
26326 PyObject * obj0 = 0 ;
26327 char * kwnames[] = {
26328 (char *) "win", NULL
26329 };
26330
26331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26333 if (!SWIG_IsOK(res1)) {
26334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26335 }
26336 arg1 = reinterpret_cast< wxWindow * >(argp1);
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (bool)wxIdleEvent::CanSend(arg1);
26340 wxPyEndAllowThreads(__tstate);
26341 if (PyErr_Occurred()) SWIG_fail;
26342 }
26343 {
26344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26345 }
26346 return resultobj;
26347 fail:
26348 return NULL;
26349 }
26350
26351
26352 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26353 PyObject *obj;
26354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26355 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26356 return SWIG_Py_Void();
26357 }
26358
26359 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26360 return SWIG_Python_InitShadowInstance(args);
26361 }
26362
26363 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26364 PyObject *resultobj = 0;
26365 int arg1 = (int) 0 ;
26366 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26367 wxPyEvent *result = 0 ;
26368 int val1 ;
26369 int ecode1 = 0 ;
26370 int val2 ;
26371 int ecode2 = 0 ;
26372 PyObject * obj0 = 0 ;
26373 PyObject * obj1 = 0 ;
26374 char * kwnames[] = {
26375 (char *) "winid",(char *) "eventType", NULL
26376 };
26377
26378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26379 if (obj0) {
26380 ecode1 = SWIG_AsVal_int(obj0, &val1);
26381 if (!SWIG_IsOK(ecode1)) {
26382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26383 }
26384 arg1 = static_cast< int >(val1);
26385 }
26386 if (obj1) {
26387 ecode2 = SWIG_AsVal_int(obj1, &val2);
26388 if (!SWIG_IsOK(ecode2)) {
26389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26390 }
26391 arg2 = static_cast< wxEventType >(val2);
26392 }
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *resultobj = 0;
26408 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 PyObject *swig_obj[1] ;
26412
26413 if (!args) SWIG_fail;
26414 swig_obj[0] = args;
26415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26416 if (!SWIG_IsOK(res1)) {
26417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26418 }
26419 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26420 {
26421 PyThreadState* __tstate = wxPyBeginAllowThreads();
26422 delete arg1;
26423
26424 wxPyEndAllowThreads(__tstate);
26425 if (PyErr_Occurred()) SWIG_fail;
26426 }
26427 resultobj = SWIG_Py_Void();
26428 return resultobj;
26429 fail:
26430 return NULL;
26431 }
26432
26433
26434 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26435 PyObject *resultobj = 0;
26436 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26437 PyObject *arg2 = (PyObject *) 0 ;
26438 void *argp1 = 0 ;
26439 int res1 = 0 ;
26440 PyObject * obj0 = 0 ;
26441 PyObject * obj1 = 0 ;
26442 char * kwnames[] = {
26443 (char *) "self",(char *) "self", NULL
26444 };
26445
26446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26448 if (!SWIG_IsOK(res1)) {
26449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26450 }
26451 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26452 arg2 = obj1;
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 (arg1)->SetSelf(arg2);
26456 wxPyEndAllowThreads(__tstate);
26457 if (PyErr_Occurred()) SWIG_fail;
26458 }
26459 resultobj = SWIG_Py_Void();
26460 return resultobj;
26461 fail:
26462 return NULL;
26463 }
26464
26465
26466 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26467 PyObject *resultobj = 0;
26468 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26469 PyObject *result = 0 ;
26470 void *argp1 = 0 ;
26471 int res1 = 0 ;
26472 PyObject *swig_obj[1] ;
26473
26474 if (!args) SWIG_fail;
26475 swig_obj[0] = args;
26476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26477 if (!SWIG_IsOK(res1)) {
26478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26479 }
26480 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 result = (PyObject *)(arg1)->GetSelf();
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 resultobj = result;
26488 return resultobj;
26489 fail:
26490 return NULL;
26491 }
26492
26493
26494 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26495 PyObject *obj;
26496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26497 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26498 return SWIG_Py_Void();
26499 }
26500
26501 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26502 return SWIG_Python_InitShadowInstance(args);
26503 }
26504
26505 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj = 0;
26507 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26508 int arg2 = (int) 0 ;
26509 wxPyCommandEvent *result = 0 ;
26510 int val1 ;
26511 int ecode1 = 0 ;
26512 int val2 ;
26513 int ecode2 = 0 ;
26514 PyObject * obj0 = 0 ;
26515 PyObject * obj1 = 0 ;
26516 char * kwnames[] = {
26517 (char *) "eventType",(char *) "id", NULL
26518 };
26519
26520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26521 if (obj0) {
26522 ecode1 = SWIG_AsVal_int(obj0, &val1);
26523 if (!SWIG_IsOK(ecode1)) {
26524 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26525 }
26526 arg1 = static_cast< wxEventType >(val1);
26527 }
26528 if (obj1) {
26529 ecode2 = SWIG_AsVal_int(obj1, &val2);
26530 if (!SWIG_IsOK(ecode2)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26532 }
26533 arg2 = static_cast< int >(val2);
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *resultobj = 0;
26550 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26551 void *argp1 = 0 ;
26552 int res1 = 0 ;
26553 PyObject *swig_obj[1] ;
26554
26555 if (!args) SWIG_fail;
26556 swig_obj[0] = args;
26557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26558 if (!SWIG_IsOK(res1)) {
26559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26560 }
26561 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 delete arg1;
26565
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 resultobj = SWIG_Py_Void();
26570 return resultobj;
26571 fail:
26572 return NULL;
26573 }
26574
26575
26576 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj = 0;
26578 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26579 PyObject *arg2 = (PyObject *) 0 ;
26580 void *argp1 = 0 ;
26581 int res1 = 0 ;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "self",(char *) "self", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26592 }
26593 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26594 arg2 = obj1;
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 (arg1)->SetSelf(arg2);
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 resultobj = SWIG_Py_Void();
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 PyObject *resultobj = 0;
26610 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26611 PyObject *result = 0 ;
26612 void *argp1 = 0 ;
26613 int res1 = 0 ;
26614 PyObject *swig_obj[1] ;
26615
26616 if (!args) SWIG_fail;
26617 swig_obj[0] = args;
26618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26619 if (!SWIG_IsOK(res1)) {
26620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26621 }
26622 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 result = (PyObject *)(arg1)->GetSelf();
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = result;
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26637 PyObject *obj;
26638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26640 return SWIG_Py_Void();
26641 }
26642
26643 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26644 return SWIG_Python_InitShadowInstance(args);
26645 }
26646
26647 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxWindow *arg1 = (wxWindow *) 0 ;
26650 wxDateTime *arg2 = 0 ;
26651 wxEventType arg3 ;
26652 wxDateEvent *result = 0 ;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 void *argp2 = 0 ;
26656 int res2 = 0 ;
26657 int val3 ;
26658 int ecode3 = 0 ;
26659 PyObject * obj0 = 0 ;
26660 PyObject * obj1 = 0 ;
26661 PyObject * obj2 = 0 ;
26662 char * kwnames[] = {
26663 (char *) "win",(char *) "dt",(char *) "type", NULL
26664 };
26665
26666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26668 if (!SWIG_IsOK(res1)) {
26669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26670 }
26671 arg1 = reinterpret_cast< wxWindow * >(argp1);
26672 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26673 if (!SWIG_IsOK(res2)) {
26674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26675 }
26676 if (!argp2) {
26677 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26678 }
26679 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26680 ecode3 = SWIG_AsVal_int(obj2, &val3);
26681 if (!SWIG_IsOK(ecode3)) {
26682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26683 }
26684 arg3 = static_cast< wxEventType >(val3);
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 PyObject *resultobj = 0;
26700 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26701 wxDateTime *result = 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject *swig_obj[1] ;
26705
26706 if (!args) SWIG_fail;
26707 swig_obj[0] = args;
26708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 {
26716 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26717 result = (wxDateTime *) &_result_ref;
26718 }
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26723 return resultobj;
26724 fail:
26725 return NULL;
26726 }
26727
26728
26729 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26730 PyObject *resultobj = 0;
26731 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26732 wxDateTime *arg2 = 0 ;
26733 void *argp1 = 0 ;
26734 int res1 = 0 ;
26735 void *argp2 = 0 ;
26736 int res2 = 0 ;
26737 PyObject * obj0 = 0 ;
26738 PyObject * obj1 = 0 ;
26739 char * kwnames[] = {
26740 (char *) "self",(char *) "date", NULL
26741 };
26742
26743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26745 if (!SWIG_IsOK(res1)) {
26746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26747 }
26748 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26749 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26750 if (!SWIG_IsOK(res2)) {
26751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26752 }
26753 if (!argp2) {
26754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26755 }
26756 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26757 {
26758 PyThreadState* __tstate = wxPyBeginAllowThreads();
26759 (arg1)->SetDate((wxDateTime const &)*arg2);
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 resultobj = SWIG_Py_Void();
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26771 PyObject *obj;
26772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26773 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26774 return SWIG_Py_Void();
26775 }
26776
26777 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 return SWIG_Python_InitShadowInstance(args);
26779 }
26780
26781 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxPyApp *result = 0 ;
26784
26785 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26786 {
26787 PyThreadState* __tstate = wxPyBeginAllowThreads();
26788 result = (wxPyApp *)new_wxPyApp();
26789 wxPyEndAllowThreads(__tstate);
26790 if (PyErr_Occurred()) SWIG_fail;
26791 }
26792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26793 return resultobj;
26794 fail:
26795 return NULL;
26796 }
26797
26798
26799 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26800 PyObject *resultobj = 0;
26801 wxPyApp *arg1 = (wxPyApp *) 0 ;
26802 void *argp1 = 0 ;
26803 int res1 = 0 ;
26804 PyObject *swig_obj[1] ;
26805
26806 if (!args) SWIG_fail;
26807 swig_obj[0] = args;
26808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26809 if (!SWIG_IsOK(res1)) {
26810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26811 }
26812 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 delete arg1;
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 resultobj = SWIG_Py_Void();
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj = 0;
26829 wxPyApp *arg1 = (wxPyApp *) 0 ;
26830 PyObject *arg2 = (PyObject *) 0 ;
26831 PyObject *arg3 = (PyObject *) 0 ;
26832 bool arg4 ;
26833 void *argp1 = 0 ;
26834 int res1 = 0 ;
26835 bool val4 ;
26836 int ecode4 = 0 ;
26837 PyObject * obj0 = 0 ;
26838 PyObject * obj1 = 0 ;
26839 PyObject * obj2 = 0 ;
26840 PyObject * obj3 = 0 ;
26841 char * kwnames[] = {
26842 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26843 };
26844
26845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26847 if (!SWIG_IsOK(res1)) {
26848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26849 }
26850 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26851 arg2 = obj1;
26852 arg3 = obj2;
26853 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26854 if (!SWIG_IsOK(ecode4)) {
26855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26856 }
26857 arg4 = static_cast< bool >(val4);
26858 {
26859 PyThreadState* __tstate = wxPyBeginAllowThreads();
26860 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26861 wxPyEndAllowThreads(__tstate);
26862 if (PyErr_Occurred()) SWIG_fail;
26863 }
26864 resultobj = SWIG_Py_Void();
26865 return resultobj;
26866 fail:
26867 return NULL;
26868 }
26869
26870
26871 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 PyObject *resultobj = 0;
26873 wxPyApp *arg1 = (wxPyApp *) 0 ;
26874 wxString result;
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_wxPyApp, 0 | 0 );
26882 if (!SWIG_IsOK(res1)) {
26883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26884 }
26885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 result = ((wxPyApp const *)arg1)->GetAppName();
26889 wxPyEndAllowThreads(__tstate);
26890 if (PyErr_Occurred()) SWIG_fail;
26891 }
26892 {
26893 #if wxUSE_UNICODE
26894 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26895 #else
26896 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26897 #endif
26898 }
26899 return resultobj;
26900 fail:
26901 return NULL;
26902 }
26903
26904
26905 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26906 PyObject *resultobj = 0;
26907 wxPyApp *arg1 = (wxPyApp *) 0 ;
26908 wxString *arg2 = 0 ;
26909 void *argp1 = 0 ;
26910 int res1 = 0 ;
26911 bool temp2 = false ;
26912 PyObject * obj0 = 0 ;
26913 PyObject * obj1 = 0 ;
26914 char * kwnames[] = {
26915 (char *) "self",(char *) "name", NULL
26916 };
26917
26918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26920 if (!SWIG_IsOK(res1)) {
26921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26922 }
26923 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26924 {
26925 arg2 = wxString_in_helper(obj1);
26926 if (arg2 == NULL) SWIG_fail;
26927 temp2 = true;
26928 }
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 (arg1)->SetAppName((wxString const &)*arg2);
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 resultobj = SWIG_Py_Void();
26936 {
26937 if (temp2)
26938 delete arg2;
26939 }
26940 return resultobj;
26941 fail:
26942 {
26943 if (temp2)
26944 delete arg2;
26945 }
26946 return NULL;
26947 }
26948
26949
26950 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26951 PyObject *resultobj = 0;
26952 wxPyApp *arg1 = (wxPyApp *) 0 ;
26953 wxString result;
26954 void *argp1 = 0 ;
26955 int res1 = 0 ;
26956 PyObject *swig_obj[1] ;
26957
26958 if (!args) SWIG_fail;
26959 swig_obj[0] = args;
26960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26961 if (!SWIG_IsOK(res1)) {
26962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26963 }
26964 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 result = ((wxPyApp const *)arg1)->GetClassName();
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 {
26972 #if wxUSE_UNICODE
26973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26974 #else
26975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26976 #endif
26977 }
26978 return resultobj;
26979 fail:
26980 return NULL;
26981 }
26982
26983
26984 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26985 PyObject *resultobj = 0;
26986 wxPyApp *arg1 = (wxPyApp *) 0 ;
26987 wxString *arg2 = 0 ;
26988 void *argp1 = 0 ;
26989 int res1 = 0 ;
26990 bool temp2 = false ;
26991 PyObject * obj0 = 0 ;
26992 PyObject * obj1 = 0 ;
26993 char * kwnames[] = {
26994 (char *) "self",(char *) "name", NULL
26995 };
26996
26997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26999 if (!SWIG_IsOK(res1)) {
27000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27001 }
27002 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27003 {
27004 arg2 = wxString_in_helper(obj1);
27005 if (arg2 == NULL) SWIG_fail;
27006 temp2 = true;
27007 }
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 (arg1)->SetClassName((wxString const &)*arg2);
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = SWIG_Py_Void();
27015 {
27016 if (temp2)
27017 delete arg2;
27018 }
27019 return resultobj;
27020 fail:
27021 {
27022 if (temp2)
27023 delete arg2;
27024 }
27025 return NULL;
27026 }
27027
27028
27029 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27030 PyObject *resultobj = 0;
27031 wxPyApp *arg1 = (wxPyApp *) 0 ;
27032 wxString *result = 0 ;
27033 void *argp1 = 0 ;
27034 int res1 = 0 ;
27035 PyObject *swig_obj[1] ;
27036
27037 if (!args) SWIG_fail;
27038 swig_obj[0] = args;
27039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27040 if (!SWIG_IsOK(res1)) {
27041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27042 }
27043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 {
27047 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27048 result = (wxString *) &_result_ref;
27049 }
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 #if wxUSE_UNICODE
27055 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27056 #else
27057 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27058 #endif
27059 }
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj = 0;
27068 wxPyApp *arg1 = (wxPyApp *) 0 ;
27069 wxString *arg2 = 0 ;
27070 void *argp1 = 0 ;
27071 int res1 = 0 ;
27072 bool temp2 = false ;
27073 PyObject * obj0 = 0 ;
27074 PyObject * obj1 = 0 ;
27075 char * kwnames[] = {
27076 (char *) "self",(char *) "name", NULL
27077 };
27078
27079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27081 if (!SWIG_IsOK(res1)) {
27082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27083 }
27084 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27085 {
27086 arg2 = wxString_in_helper(obj1);
27087 if (arg2 == NULL) SWIG_fail;
27088 temp2 = true;
27089 }
27090 {
27091 PyThreadState* __tstate = wxPyBeginAllowThreads();
27092 (arg1)->SetVendorName((wxString const &)*arg2);
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 resultobj = SWIG_Py_Void();
27097 {
27098 if (temp2)
27099 delete arg2;
27100 }
27101 return resultobj;
27102 fail:
27103 {
27104 if (temp2)
27105 delete arg2;
27106 }
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27112 PyObject *resultobj = 0;
27113 wxPyApp *arg1 = (wxPyApp *) 0 ;
27114 wxAppTraits *result = 0 ;
27115 void *argp1 = 0 ;
27116 int res1 = 0 ;
27117 PyObject *swig_obj[1] ;
27118
27119 if (!args) SWIG_fail;
27120 swig_obj[0] = args;
27121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27122 if (!SWIG_IsOK(res1)) {
27123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27124 }
27125 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (wxAppTraits *)(arg1)->GetTraits();
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27133 return resultobj;
27134 fail:
27135 return NULL;
27136 }
27137
27138
27139 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27140 PyObject *resultobj = 0;
27141 wxPyApp *arg1 = (wxPyApp *) 0 ;
27142 void *argp1 = 0 ;
27143 int res1 = 0 ;
27144 PyObject *swig_obj[1] ;
27145
27146 if (!args) SWIG_fail;
27147 swig_obj[0] = args;
27148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27149 if (!SWIG_IsOK(res1)) {
27150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27151 }
27152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27153 {
27154 PyThreadState* __tstate = wxPyBeginAllowThreads();
27155 (arg1)->ProcessPendingEvents();
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 resultobj = SWIG_Py_Void();
27160 return resultobj;
27161 fail:
27162 return NULL;
27163 }
27164
27165
27166 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27167 PyObject *resultobj = 0;
27168 wxPyApp *arg1 = (wxPyApp *) 0 ;
27169 bool arg2 = (bool) false ;
27170 bool result;
27171 void *argp1 = 0 ;
27172 int res1 = 0 ;
27173 bool val2 ;
27174 int ecode2 = 0 ;
27175 PyObject * obj0 = 0 ;
27176 PyObject * obj1 = 0 ;
27177 char * kwnames[] = {
27178 (char *) "self",(char *) "onlyIfNeeded", NULL
27179 };
27180
27181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27183 if (!SWIG_IsOK(res1)) {
27184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27185 }
27186 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27187 if (obj1) {
27188 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27189 if (!SWIG_IsOK(ecode2)) {
27190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27191 }
27192 arg2 = static_cast< bool >(val2);
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 result = (bool)(arg1)->Yield(arg2);
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 {
27201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27202 }
27203 return resultobj;
27204 fail:
27205 return NULL;
27206 }
27207
27208
27209 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27210 PyObject *resultobj = 0;
27211 wxPyApp *arg1 = (wxPyApp *) 0 ;
27212 void *argp1 = 0 ;
27213 int res1 = 0 ;
27214 PyObject *swig_obj[1] ;
27215
27216 if (!args) SWIG_fail;
27217 swig_obj[0] = args;
27218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27219 if (!SWIG_IsOK(res1)) {
27220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27221 }
27222 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->WakeUpIdle();
27226 wxPyEndAllowThreads(__tstate);
27227 if (PyErr_Occurred()) SWIG_fail;
27228 }
27229 resultobj = SWIG_Py_Void();
27230 return resultobj;
27231 fail:
27232 return NULL;
27233 }
27234
27235
27236 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27237 PyObject *resultobj = 0;
27238 bool result;
27239
27240 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27241 {
27242 PyThreadState* __tstate = wxPyBeginAllowThreads();
27243 result = (bool)wxPyApp::IsMainLoopRunning();
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 {
27248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27249 }
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27257 PyObject *resultobj = 0;
27258 wxPyApp *arg1 = (wxPyApp *) 0 ;
27259 int result;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 PyObject *swig_obj[1] ;
27263
27264 if (!args) SWIG_fail;
27265 swig_obj[0] = args;
27266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27267 if (!SWIG_IsOK(res1)) {
27268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27269 }
27270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = (int)(arg1)->MainLoop();
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 resultobj = SWIG_From_int(static_cast< int >(result));
27278 return resultobj;
27279 fail:
27280 return NULL;
27281 }
27282
27283
27284 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27285 PyObject *resultobj = 0;
27286 wxPyApp *arg1 = (wxPyApp *) 0 ;
27287 void *argp1 = 0 ;
27288 int res1 = 0 ;
27289 PyObject *swig_obj[1] ;
27290
27291 if (!args) SWIG_fail;
27292 swig_obj[0] = args;
27293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27294 if (!SWIG_IsOK(res1)) {
27295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27296 }
27297 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27298 {
27299 PyThreadState* __tstate = wxPyBeginAllowThreads();
27300 (arg1)->Exit();
27301 wxPyEndAllowThreads(__tstate);
27302 if (PyErr_Occurred()) SWIG_fail;
27303 }
27304 resultobj = SWIG_Py_Void();
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27312 PyObject *resultobj = 0;
27313 wxPyApp *arg1 = (wxPyApp *) 0 ;
27314 void *argp1 = 0 ;
27315 int res1 = 0 ;
27316 PyObject *swig_obj[1] ;
27317
27318 if (!args) SWIG_fail;
27319 swig_obj[0] = args;
27320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27321 if (!SWIG_IsOK(res1)) {
27322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27323 }
27324 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 (arg1)->ExitMainLoop();
27328 wxPyEndAllowThreads(__tstate);
27329 if (PyErr_Occurred()) SWIG_fail;
27330 }
27331 resultobj = SWIG_Py_Void();
27332 return resultobj;
27333 fail:
27334 return NULL;
27335 }
27336
27337
27338 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27339 PyObject *resultobj = 0;
27340 wxPyApp *arg1 = (wxPyApp *) 0 ;
27341 bool result;
27342 void *argp1 = 0 ;
27343 int res1 = 0 ;
27344 PyObject *swig_obj[1] ;
27345
27346 if (!args) SWIG_fail;
27347 swig_obj[0] = args;
27348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27351 }
27352 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = (bool)(arg1)->Pending();
27356 wxPyEndAllowThreads(__tstate);
27357 if (PyErr_Occurred()) SWIG_fail;
27358 }
27359 {
27360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27361 }
27362 return resultobj;
27363 fail:
27364 return NULL;
27365 }
27366
27367
27368 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27369 PyObject *resultobj = 0;
27370 wxPyApp *arg1 = (wxPyApp *) 0 ;
27371 bool result;
27372 void *argp1 = 0 ;
27373 int res1 = 0 ;
27374 PyObject *swig_obj[1] ;
27375
27376 if (!args) SWIG_fail;
27377 swig_obj[0] = args;
27378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27379 if (!SWIG_IsOK(res1)) {
27380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27381 }
27382 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27383 {
27384 PyThreadState* __tstate = wxPyBeginAllowThreads();
27385 result = (bool)(arg1)->Dispatch();
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 {
27390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27391 }
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27399 PyObject *resultobj = 0;
27400 wxPyApp *arg1 = (wxPyApp *) 0 ;
27401 bool result;
27402 void *argp1 = 0 ;
27403 int res1 = 0 ;
27404 PyObject *swig_obj[1] ;
27405
27406 if (!args) SWIG_fail;
27407 swig_obj[0] = args;
27408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27409 if (!SWIG_IsOK(res1)) {
27410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27411 }
27412 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27413 {
27414 PyThreadState* __tstate = wxPyBeginAllowThreads();
27415 result = (bool)(arg1)->ProcessIdle();
27416 wxPyEndAllowThreads(__tstate);
27417 if (PyErr_Occurred()) SWIG_fail;
27418 }
27419 {
27420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27421 }
27422 return resultobj;
27423 fail:
27424 return NULL;
27425 }
27426
27427
27428 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27429 PyObject *resultobj = 0;
27430 wxPyApp *arg1 = (wxPyApp *) 0 ;
27431 wxWindow *arg2 = (wxWindow *) 0 ;
27432 wxIdleEvent *arg3 = 0 ;
27433 bool result;
27434 void *argp1 = 0 ;
27435 int res1 = 0 ;
27436 void *argp2 = 0 ;
27437 int res2 = 0 ;
27438 void *argp3 = 0 ;
27439 int res3 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 PyObject * obj2 = 0 ;
27443 char * kwnames[] = {
27444 (char *) "self",(char *) "win",(char *) "event", NULL
27445 };
27446
27447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27451 }
27452 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27453 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27454 if (!SWIG_IsOK(res2)) {
27455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27456 }
27457 arg2 = reinterpret_cast< wxWindow * >(argp2);
27458 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27459 if (!SWIG_IsOK(res3)) {
27460 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27461 }
27462 if (!argp3) {
27463 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27464 }
27465 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27466 {
27467 PyThreadState* __tstate = wxPyBeginAllowThreads();
27468 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27469 wxPyEndAllowThreads(__tstate);
27470 if (PyErr_Occurred()) SWIG_fail;
27471 }
27472 {
27473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27474 }
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 PyObject *resultobj = 0;
27483 wxPyApp *arg1 = (wxPyApp *) 0 ;
27484 bool result;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject *swig_obj[1] ;
27488
27489 if (!args) SWIG_fail;
27490 swig_obj[0] = args;
27491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27494 }
27495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 result = (bool)((wxPyApp const *)arg1)->IsActive();
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 {
27503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 wxPyApp *arg1 = (wxPyApp *) 0 ;
27514 wxWindow *arg2 = (wxWindow *) 0 ;
27515 void *argp1 = 0 ;
27516 int res1 = 0 ;
27517 void *argp2 = 0 ;
27518 int res2 = 0 ;
27519 PyObject * obj0 = 0 ;
27520 PyObject * obj1 = 0 ;
27521 char * kwnames[] = {
27522 (char *) "self",(char *) "win", NULL
27523 };
27524
27525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27527 if (!SWIG_IsOK(res1)) {
27528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27529 }
27530 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27531 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27532 if (!SWIG_IsOK(res2)) {
27533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27534 }
27535 arg2 = reinterpret_cast< wxWindow * >(argp2);
27536 {
27537 PyThreadState* __tstate = wxPyBeginAllowThreads();
27538 (arg1)->SetTopWindow(arg2);
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 resultobj = SWIG_Py_Void();
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 PyObject *resultobj = 0;
27551 wxPyApp *arg1 = (wxPyApp *) 0 ;
27552 wxWindow *result = 0 ;
27553 void *argp1 = 0 ;
27554 int res1 = 0 ;
27555 PyObject *swig_obj[1] ;
27556
27557 if (!args) SWIG_fail;
27558 swig_obj[0] = args;
27559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27560 if (!SWIG_IsOK(res1)) {
27561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27562 }
27563 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27567 wxPyEndAllowThreads(__tstate);
27568 if (PyErr_Occurred()) SWIG_fail;
27569 }
27570 {
27571 resultobj = wxPyMake_wxObject(result, (bool)0);
27572 }
27573 return resultobj;
27574 fail:
27575 return NULL;
27576 }
27577
27578
27579 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27580 PyObject *resultobj = 0;
27581 wxPyApp *arg1 = (wxPyApp *) 0 ;
27582 bool arg2 ;
27583 void *argp1 = 0 ;
27584 int res1 = 0 ;
27585 bool val2 ;
27586 int ecode2 = 0 ;
27587 PyObject * obj0 = 0 ;
27588 PyObject * obj1 = 0 ;
27589 char * kwnames[] = {
27590 (char *) "self",(char *) "flag", NULL
27591 };
27592
27593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27595 if (!SWIG_IsOK(res1)) {
27596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27597 }
27598 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27599 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27600 if (!SWIG_IsOK(ecode2)) {
27601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27602 }
27603 arg2 = static_cast< bool >(val2);
27604 {
27605 PyThreadState* __tstate = wxPyBeginAllowThreads();
27606 (arg1)->SetExitOnFrameDelete(arg2);
27607 wxPyEndAllowThreads(__tstate);
27608 if (PyErr_Occurred()) SWIG_fail;
27609 }
27610 resultobj = SWIG_Py_Void();
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 PyObject *resultobj = 0;
27619 wxPyApp *arg1 = (wxPyApp *) 0 ;
27620 bool result;
27621 void *argp1 = 0 ;
27622 int res1 = 0 ;
27623 PyObject *swig_obj[1] ;
27624
27625 if (!args) SWIG_fail;
27626 swig_obj[0] = args;
27627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27630 }
27631 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 {
27639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27640 }
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj = 0;
27649 wxPyApp *arg1 = (wxPyApp *) 0 ;
27650 bool arg2 ;
27651 void *argp1 = 0 ;
27652 int res1 = 0 ;
27653 bool val2 ;
27654 int ecode2 = 0 ;
27655 PyObject * obj0 = 0 ;
27656 PyObject * obj1 = 0 ;
27657 char * kwnames[] = {
27658 (char *) "self",(char *) "flag", NULL
27659 };
27660
27661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27663 if (!SWIG_IsOK(res1)) {
27664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27665 }
27666 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27667 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27668 if (!SWIG_IsOK(ecode2)) {
27669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27670 }
27671 arg2 = static_cast< bool >(val2);
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 (arg1)->SetUseBestVisual(arg2);
27675 wxPyEndAllowThreads(__tstate);
27676 if (PyErr_Occurred()) SWIG_fail;
27677 }
27678 resultobj = SWIG_Py_Void();
27679 return resultobj;
27680 fail:
27681 return NULL;
27682 }
27683
27684
27685 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27686 PyObject *resultobj = 0;
27687 wxPyApp *arg1 = (wxPyApp *) 0 ;
27688 bool result;
27689 void *argp1 = 0 ;
27690 int res1 = 0 ;
27691 PyObject *swig_obj[1] ;
27692
27693 if (!args) SWIG_fail;
27694 swig_obj[0] = args;
27695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27696 if (!SWIG_IsOK(res1)) {
27697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27698 }
27699 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27700 {
27701 PyThreadState* __tstate = wxPyBeginAllowThreads();
27702 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27703 wxPyEndAllowThreads(__tstate);
27704 if (PyErr_Occurred()) SWIG_fail;
27705 }
27706 {
27707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27708 }
27709 return resultobj;
27710 fail:
27711 return NULL;
27712 }
27713
27714
27715 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27716 PyObject *resultobj = 0;
27717 wxPyApp *arg1 = (wxPyApp *) 0 ;
27718 int arg2 ;
27719 void *argp1 = 0 ;
27720 int res1 = 0 ;
27721 int val2 ;
27722 int ecode2 = 0 ;
27723 PyObject * obj0 = 0 ;
27724 PyObject * obj1 = 0 ;
27725 char * kwnames[] = {
27726 (char *) "self",(char *) "mode", NULL
27727 };
27728
27729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27731 if (!SWIG_IsOK(res1)) {
27732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27733 }
27734 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27735 ecode2 = SWIG_AsVal_int(obj1, &val2);
27736 if (!SWIG_IsOK(ecode2)) {
27737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27738 }
27739 arg2 = static_cast< int >(val2);
27740 {
27741 PyThreadState* __tstate = wxPyBeginAllowThreads();
27742 (arg1)->SetPrintMode(arg2);
27743 wxPyEndAllowThreads(__tstate);
27744 if (PyErr_Occurred()) SWIG_fail;
27745 }
27746 resultobj = SWIG_Py_Void();
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27754 PyObject *resultobj = 0;
27755 wxPyApp *arg1 = (wxPyApp *) 0 ;
27756 int result;
27757 void *argp1 = 0 ;
27758 int res1 = 0 ;
27759 PyObject *swig_obj[1] ;
27760
27761 if (!args) SWIG_fail;
27762 swig_obj[0] = args;
27763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27764 if (!SWIG_IsOK(res1)) {
27765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27766 }
27767 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27768 {
27769 PyThreadState* __tstate = wxPyBeginAllowThreads();
27770 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 resultobj = SWIG_From_int(static_cast< int >(result));
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj = 0;
27783 wxPyApp *arg1 = (wxPyApp *) 0 ;
27784 int arg2 ;
27785 void *argp1 = 0 ;
27786 int res1 = 0 ;
27787 int val2 ;
27788 int ecode2 = 0 ;
27789 PyObject * obj0 = 0 ;
27790 PyObject * obj1 = 0 ;
27791 char * kwnames[] = {
27792 (char *) "self",(char *) "mode", NULL
27793 };
27794
27795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27799 }
27800 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27801 ecode2 = SWIG_AsVal_int(obj1, &val2);
27802 if (!SWIG_IsOK(ecode2)) {
27803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27804 }
27805 arg2 = static_cast< int >(val2);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 (arg1)->SetAssertMode(arg2);
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 resultobj = SWIG_Py_Void();
27813 return resultobj;
27814 fail:
27815 return NULL;
27816 }
27817
27818
27819 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27820 PyObject *resultobj = 0;
27821 wxPyApp *arg1 = (wxPyApp *) 0 ;
27822 int result;
27823 void *argp1 = 0 ;
27824 int res1 = 0 ;
27825 PyObject *swig_obj[1] ;
27826
27827 if (!args) SWIG_fail;
27828 swig_obj[0] = args;
27829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27830 if (!SWIG_IsOK(res1)) {
27831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27832 }
27833 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (int)(arg1)->GetAssertMode();
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_From_int(static_cast< int >(result));
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27848 PyObject *resultobj = 0;
27849 bool result;
27850
27851 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 {
27859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27860 }
27861 return resultobj;
27862 fail:
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 long result;
27870
27871 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (long)wxPyApp::GetMacAboutMenuItemId();
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 resultobj = SWIG_From_long(static_cast< long >(result));
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 long result;
27888
27889 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = SWIG_From_long(static_cast< long >(result));
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27904 PyObject *resultobj = 0;
27905 long result;
27906
27907 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27908 {
27909 PyThreadState* __tstate = wxPyBeginAllowThreads();
27910 result = (long)wxPyApp::GetMacExitMenuItemId();
27911 wxPyEndAllowThreads(__tstate);
27912 if (PyErr_Occurred()) SWIG_fail;
27913 }
27914 resultobj = SWIG_From_long(static_cast< long >(result));
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27922 PyObject *resultobj = 0;
27923 wxString result;
27924
27925 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 result = wxPyApp::GetMacHelpMenuTitleName();
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 {
27933 #if wxUSE_UNICODE
27934 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27935 #else
27936 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27937 #endif
27938 }
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj = 0;
27947 bool arg1 ;
27948 bool val1 ;
27949 int ecode1 = 0 ;
27950 PyObject * obj0 = 0 ;
27951 char * kwnames[] = {
27952 (char *) "val", NULL
27953 };
27954
27955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27956 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27957 if (!SWIG_IsOK(ecode1)) {
27958 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27959 }
27960 arg1 = static_cast< bool >(val1);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 resultobj = SWIG_Py_Void();
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27975 PyObject *resultobj = 0;
27976 long arg1 ;
27977 long val1 ;
27978 int ecode1 = 0 ;
27979 PyObject * obj0 = 0 ;
27980 char * kwnames[] = {
27981 (char *) "val", NULL
27982 };
27983
27984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27985 ecode1 = SWIG_AsVal_long(obj0, &val1);
27986 if (!SWIG_IsOK(ecode1)) {
27987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27988 }
27989 arg1 = static_cast< long >(val1);
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 wxPyApp::SetMacAboutMenuItemId(arg1);
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 resultobj = SWIG_Py_Void();
27997 return resultobj;
27998 fail:
27999 return NULL;
28000 }
28001
28002
28003 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28004 PyObject *resultobj = 0;
28005 long arg1 ;
28006 long val1 ;
28007 int ecode1 = 0 ;
28008 PyObject * obj0 = 0 ;
28009 char * kwnames[] = {
28010 (char *) "val", NULL
28011 };
28012
28013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28014 ecode1 = SWIG_AsVal_long(obj0, &val1);
28015 if (!SWIG_IsOK(ecode1)) {
28016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28017 }
28018 arg1 = static_cast< long >(val1);
28019 {
28020 PyThreadState* __tstate = wxPyBeginAllowThreads();
28021 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28022 wxPyEndAllowThreads(__tstate);
28023 if (PyErr_Occurred()) SWIG_fail;
28024 }
28025 resultobj = SWIG_Py_Void();
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj = 0;
28034 long arg1 ;
28035 long val1 ;
28036 int ecode1 = 0 ;
28037 PyObject * obj0 = 0 ;
28038 char * kwnames[] = {
28039 (char *) "val", NULL
28040 };
28041
28042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28043 ecode1 = SWIG_AsVal_long(obj0, &val1);
28044 if (!SWIG_IsOK(ecode1)) {
28045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28046 }
28047 arg1 = static_cast< long >(val1);
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 wxPyApp::SetMacExitMenuItemId(arg1);
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 resultobj = SWIG_Py_Void();
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28062 PyObject *resultobj = 0;
28063 wxString *arg1 = 0 ;
28064 bool temp1 = false ;
28065 PyObject * obj0 = 0 ;
28066 char * kwnames[] = {
28067 (char *) "val", NULL
28068 };
28069
28070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28071 {
28072 arg1 = wxString_in_helper(obj0);
28073 if (arg1 == NULL) SWIG_fail;
28074 temp1 = true;
28075 }
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28079 wxPyEndAllowThreads(__tstate);
28080 if (PyErr_Occurred()) SWIG_fail;
28081 }
28082 resultobj = SWIG_Py_Void();
28083 {
28084 if (temp1)
28085 delete arg1;
28086 }
28087 return resultobj;
28088 fail:
28089 {
28090 if (temp1)
28091 delete arg1;
28092 }
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28098 PyObject *resultobj = 0;
28099 wxPyApp *arg1 = (wxPyApp *) 0 ;
28100 void *argp1 = 0 ;
28101 int res1 = 0 ;
28102 PyObject *swig_obj[1] ;
28103
28104 if (!args) SWIG_fail;
28105 swig_obj[0] = args;
28106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28107 if (!SWIG_IsOK(res1)) {
28108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28109 }
28110 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 (arg1)->_BootstrapApp();
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 resultobj = SWIG_Py_Void();
28118 return resultobj;
28119 fail:
28120 return NULL;
28121 }
28122
28123
28124 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28125 PyObject *resultobj = 0;
28126 int result;
28127
28128 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (int)wxPyApp::GetComCtl32Version();
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 resultobj = SWIG_From_int(static_cast< int >(result));
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28143 PyObject *obj;
28144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28145 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28146 return SWIG_Py_Void();
28147 }
28148
28149 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28150 return SWIG_Python_InitShadowInstance(args);
28151 }
28152
28153 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 PyObject *resultobj = 0;
28155
28156 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28157 {
28158 PyThreadState* __tstate = wxPyBeginAllowThreads();
28159 wxExit();
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = SWIG_Py_Void();
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28171 PyObject *resultobj = 0;
28172 bool result;
28173
28174 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = (bool)wxYield();
28178 wxPyEndAllowThreads(__tstate);
28179 if (PyErr_Occurred()) SWIG_fail;
28180 }
28181 {
28182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28183 }
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28191 PyObject *resultobj = 0;
28192 bool result;
28193
28194 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (bool)wxYieldIfNeeded();
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 {
28202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28203 }
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28211 PyObject *resultobj = 0;
28212 wxWindow *arg1 = (wxWindow *) NULL ;
28213 bool arg2 = (bool) false ;
28214 bool result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 bool val2 ;
28218 int ecode2 = 0 ;
28219 PyObject * obj0 = 0 ;
28220 PyObject * obj1 = 0 ;
28221 char * kwnames[] = {
28222 (char *) "win",(char *) "onlyIfNeeded", NULL
28223 };
28224
28225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28226 if (obj0) {
28227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28228 if (!SWIG_IsOK(res1)) {
28229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28230 }
28231 arg1 = reinterpret_cast< wxWindow * >(argp1);
28232 }
28233 if (obj1) {
28234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28235 if (!SWIG_IsOK(ecode2)) {
28236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28237 }
28238 arg2 = static_cast< bool >(val2);
28239 }
28240 {
28241 PyThreadState* __tstate = wxPyBeginAllowThreads();
28242 result = (bool)wxSafeYield(arg1,arg2);
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 {
28247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28248 }
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28256 PyObject *resultobj = 0;
28257
28258 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28259 {
28260 PyThreadState* __tstate = wxPyBeginAllowThreads();
28261 wxWakeUpIdle();
28262 wxPyEndAllowThreads(__tstate);
28263 if (PyErr_Occurred()) SWIG_fail;
28264 }
28265 resultobj = SWIG_Py_Void();
28266 return resultobj;
28267 fail:
28268 return NULL;
28269 }
28270
28271
28272 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28273 PyObject *resultobj = 0;
28274 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28275 wxEvent *arg2 = 0 ;
28276 void *argp1 = 0 ;
28277 int res1 = 0 ;
28278 void *argp2 = 0 ;
28279 int res2 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 PyObject * obj1 = 0 ;
28282 char * kwnames[] = {
28283 (char *) "dest",(char *) "event", NULL
28284 };
28285
28286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28288 if (!SWIG_IsOK(res1)) {
28289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28290 }
28291 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28292 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28293 if (!SWIG_IsOK(res2)) {
28294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28295 }
28296 if (!argp2) {
28297 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28298 }
28299 arg2 = reinterpret_cast< wxEvent * >(argp2);
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 wxPostEvent(arg1,*arg2);
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 resultobj = SWIG_Py_Void();
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28314 PyObject *resultobj = 0;
28315
28316 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28317 {
28318 PyThreadState* __tstate = wxPyBeginAllowThreads();
28319 wxApp_CleanUp();
28320 wxPyEndAllowThreads(__tstate);
28321 if (PyErr_Occurred()) SWIG_fail;
28322 }
28323 resultobj = SWIG_Py_Void();
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28331 PyObject *resultobj = 0;
28332 wxPyApp *result = 0 ;
28333
28334 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28335 {
28336 PyThreadState* __tstate = wxPyBeginAllowThreads();
28337 result = (wxPyApp *)wxPyGetApp();
28338 wxPyEndAllowThreads(__tstate);
28339 if (PyErr_Occurred()) SWIG_fail;
28340 }
28341 {
28342 resultobj = wxPyMake_wxObject(result, 0);
28343 }
28344 return resultobj;
28345 fail:
28346 return NULL;
28347 }
28348
28349
28350 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28351 PyObject *resultobj = 0;
28352 char *arg1 = (char *) 0 ;
28353 int res1 ;
28354 char *buf1 = 0 ;
28355 int alloc1 = 0 ;
28356 PyObject * obj0 = 0 ;
28357 char * kwnames[] = {
28358 (char *) "encoding", NULL
28359 };
28360
28361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28362 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28363 if (!SWIG_IsOK(res1)) {
28364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28365 }
28366 arg1 = buf1;
28367 {
28368 PyThreadState* __tstate = wxPyBeginAllowThreads();
28369 wxSetDefaultPyEncoding((char const *)arg1);
28370 wxPyEndAllowThreads(__tstate);
28371 if (PyErr_Occurred()) SWIG_fail;
28372 }
28373 resultobj = SWIG_Py_Void();
28374 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28375 return resultobj;
28376 fail:
28377 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28378 return NULL;
28379 }
28380
28381
28382 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28383 PyObject *resultobj = 0;
28384 char *result = 0 ;
28385
28386 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28387 {
28388 PyThreadState* __tstate = wxPyBeginAllowThreads();
28389 result = (char *)wxGetDefaultPyEncoding();
28390 wxPyEndAllowThreads(__tstate);
28391 if (PyErr_Occurred()) SWIG_fail;
28392 }
28393 resultobj = SWIG_FromCharPtr(result);
28394 return resultobj;
28395 fail:
28396 return NULL;
28397 }
28398
28399
28400 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 PyObject *resultobj = 0;
28402 wxEventLoop *result = 0 ;
28403
28404 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (wxEventLoop *)new wxEventLoop();
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28419 PyObject *resultobj = 0;
28420 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28421 void *argp1 = 0 ;
28422 int res1 = 0 ;
28423 PyObject *swig_obj[1] ;
28424
28425 if (!args) SWIG_fail;
28426 swig_obj[0] = args;
28427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28428 if (!SWIG_IsOK(res1)) {
28429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28430 }
28431 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28432 {
28433 PyThreadState* __tstate = wxPyBeginAllowThreads();
28434 delete arg1;
28435
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_Py_Void();
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28447 PyObject *resultobj = 0;
28448 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28449 int result;
28450 void *argp1 = 0 ;
28451 int res1 = 0 ;
28452 PyObject *swig_obj[1] ;
28453
28454 if (!args) SWIG_fail;
28455 swig_obj[0] = args;
28456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28457 if (!SWIG_IsOK(res1)) {
28458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28459 }
28460 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 result = (int)(arg1)->Run();
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_From_int(static_cast< int >(result));
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj = 0;
28476 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28477 int arg2 = (int) 0 ;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 int val2 ;
28481 int ecode2 = 0 ;
28482 PyObject * obj0 = 0 ;
28483 PyObject * obj1 = 0 ;
28484 char * kwnames[] = {
28485 (char *) "self",(char *) "rc", NULL
28486 };
28487
28488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28490 if (!SWIG_IsOK(res1)) {
28491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28492 }
28493 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28494 if (obj1) {
28495 ecode2 = SWIG_AsVal_int(obj1, &val2);
28496 if (!SWIG_IsOK(ecode2)) {
28497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28498 }
28499 arg2 = static_cast< int >(val2);
28500 }
28501 {
28502 PyThreadState* __tstate = wxPyBeginAllowThreads();
28503 (arg1)->Exit(arg2);
28504 wxPyEndAllowThreads(__tstate);
28505 if (PyErr_Occurred()) SWIG_fail;
28506 }
28507 resultobj = SWIG_Py_Void();
28508 return resultobj;
28509 fail:
28510 return NULL;
28511 }
28512
28513
28514 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28515 PyObject *resultobj = 0;
28516 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28517 bool result;
28518 void *argp1 = 0 ;
28519 int res1 = 0 ;
28520 PyObject *swig_obj[1] ;
28521
28522 if (!args) SWIG_fail;
28523 swig_obj[0] = args;
28524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28525 if (!SWIG_IsOK(res1)) {
28526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28527 }
28528 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28529 {
28530 PyThreadState* __tstate = wxPyBeginAllowThreads();
28531 result = (bool)((wxEventLoop const *)arg1)->Pending();
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28545 PyObject *resultobj = 0;
28546 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28547 bool result;
28548 void *argp1 = 0 ;
28549 int res1 = 0 ;
28550 PyObject *swig_obj[1] ;
28551
28552 if (!args) SWIG_fail;
28553 swig_obj[0] = args;
28554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28555 if (!SWIG_IsOK(res1)) {
28556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28557 }
28558 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 result = (bool)(arg1)->Dispatch();
28562 wxPyEndAllowThreads(__tstate);
28563 if (PyErr_Occurred()) SWIG_fail;
28564 }
28565 {
28566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28567 }
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28575 PyObject *resultobj = 0;
28576 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28577 bool result;
28578 void *argp1 = 0 ;
28579 int res1 = 0 ;
28580 PyObject *swig_obj[1] ;
28581
28582 if (!args) SWIG_fail;
28583 swig_obj[0] = args;
28584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28585 if (!SWIG_IsOK(res1)) {
28586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28587 }
28588 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 {
28596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28597 }
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28605 PyObject *resultobj = 0;
28606 wxEventLoop *result = 0 ;
28607
28608 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28609 {
28610 PyThreadState* __tstate = wxPyBeginAllowThreads();
28611 result = (wxEventLoop *)wxEventLoop::GetActive();
28612 wxPyEndAllowThreads(__tstate);
28613 if (PyErr_Occurred()) SWIG_fail;
28614 }
28615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj = 0;
28624 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28625 void *argp1 = 0 ;
28626 int res1 = 0 ;
28627 PyObject * obj0 = 0 ;
28628 char * kwnames[] = {
28629 (char *) "loop", NULL
28630 };
28631
28632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28634 if (!SWIG_IsOK(res1)) {
28635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28636 }
28637 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28638 {
28639 PyThreadState* __tstate = wxPyBeginAllowThreads();
28640 wxEventLoop::SetActive(arg1);
28641 wxPyEndAllowThreads(__tstate);
28642 if (PyErr_Occurred()) SWIG_fail;
28643 }
28644 resultobj = SWIG_Py_Void();
28645 return resultobj;
28646 fail:
28647 return NULL;
28648 }
28649
28650
28651 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28652 PyObject *obj;
28653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28654 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28655 return SWIG_Py_Void();
28656 }
28657
28658 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28659 return SWIG_Python_InitShadowInstance(args);
28660 }
28661
28662 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj = 0;
28664 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28665 wxEventLoopActivator *result = 0 ;
28666 void *argp1 = 0 ;
28667 int res1 = 0 ;
28668 PyObject * obj0 = 0 ;
28669 char * kwnames[] = {
28670 (char *) "evtLoop", NULL
28671 };
28672
28673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28675 if (!SWIG_IsOK(res1)) {
28676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28677 }
28678 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28695 void *argp1 = 0 ;
28696 int res1 = 0 ;
28697 PyObject *swig_obj[1] ;
28698
28699 if (!args) SWIG_fail;
28700 swig_obj[0] = args;
28701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28702 if (!SWIG_IsOK(res1)) {
28703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28704 }
28705 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 delete arg1;
28709
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_Py_Void();
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28721 PyObject *obj;
28722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28723 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28724 return SWIG_Py_Void();
28725 }
28726
28727 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28728 return SWIG_Python_InitShadowInstance(args);
28729 }
28730
28731 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28732 PyObject *resultobj = 0;
28733 int arg1 = (int) 0 ;
28734 int arg2 = (int) 0 ;
28735 int arg3 = (int) 0 ;
28736 wxAcceleratorEntry *result = 0 ;
28737 int val1 ;
28738 int ecode1 = 0 ;
28739 int val2 ;
28740 int ecode2 = 0 ;
28741 int val3 ;
28742 int ecode3 = 0 ;
28743 PyObject * obj0 = 0 ;
28744 PyObject * obj1 = 0 ;
28745 PyObject * obj2 = 0 ;
28746 char * kwnames[] = {
28747 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28748 };
28749
28750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28751 if (obj0) {
28752 ecode1 = SWIG_AsVal_int(obj0, &val1);
28753 if (!SWIG_IsOK(ecode1)) {
28754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28755 }
28756 arg1 = static_cast< int >(val1);
28757 }
28758 if (obj1) {
28759 ecode2 = SWIG_AsVal_int(obj1, &val2);
28760 if (!SWIG_IsOK(ecode2)) {
28761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28762 }
28763 arg2 = static_cast< int >(val2);
28764 }
28765 if (obj2) {
28766 ecode3 = SWIG_AsVal_int(obj2, &val3);
28767 if (!SWIG_IsOK(ecode3)) {
28768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28769 }
28770 arg3 = static_cast< int >(val3);
28771 }
28772 {
28773 PyThreadState* __tstate = wxPyBeginAllowThreads();
28774 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28779 return resultobj;
28780 fail:
28781 return NULL;
28782 }
28783
28784
28785 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28786 PyObject *resultobj = 0;
28787 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28788 void *argp1 = 0 ;
28789 int res1 = 0 ;
28790 PyObject *swig_obj[1] ;
28791
28792 if (!args) SWIG_fail;
28793 swig_obj[0] = args;
28794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28795 if (!SWIG_IsOK(res1)) {
28796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28797 }
28798 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 delete arg1;
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_Py_Void();
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj = 0;
28815 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28816 int arg2 ;
28817 int arg3 ;
28818 int arg4 ;
28819 void *argp1 = 0 ;
28820 int res1 = 0 ;
28821 int val2 ;
28822 int ecode2 = 0 ;
28823 int val3 ;
28824 int ecode3 = 0 ;
28825 int val4 ;
28826 int ecode4 = 0 ;
28827 PyObject * obj0 = 0 ;
28828 PyObject * obj1 = 0 ;
28829 PyObject * obj2 = 0 ;
28830 PyObject * obj3 = 0 ;
28831 char * kwnames[] = {
28832 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28833 };
28834
28835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28837 if (!SWIG_IsOK(res1)) {
28838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28839 }
28840 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28841 ecode2 = SWIG_AsVal_int(obj1, &val2);
28842 if (!SWIG_IsOK(ecode2)) {
28843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28844 }
28845 arg2 = static_cast< int >(val2);
28846 ecode3 = SWIG_AsVal_int(obj2, &val3);
28847 if (!SWIG_IsOK(ecode3)) {
28848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28849 }
28850 arg3 = static_cast< int >(val3);
28851 ecode4 = SWIG_AsVal_int(obj3, &val4);
28852 if (!SWIG_IsOK(ecode4)) {
28853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28854 }
28855 arg4 = static_cast< int >(val4);
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 (arg1)->Set(arg2,arg3,arg4);
28859 wxPyEndAllowThreads(__tstate);
28860 if (PyErr_Occurred()) SWIG_fail;
28861 }
28862 resultobj = SWIG_Py_Void();
28863 return resultobj;
28864 fail:
28865 return NULL;
28866 }
28867
28868
28869 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28870 PyObject *resultobj = 0;
28871 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28872 int result;
28873 void *argp1 = 0 ;
28874 int res1 = 0 ;
28875 PyObject *swig_obj[1] ;
28876
28877 if (!args) SWIG_fail;
28878 swig_obj[0] = args;
28879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28880 if (!SWIG_IsOK(res1)) {
28881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28882 }
28883 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 result = (int)(arg1)->GetFlags();
28887 wxPyEndAllowThreads(__tstate);
28888 if (PyErr_Occurred()) SWIG_fail;
28889 }
28890 resultobj = SWIG_From_int(static_cast< int >(result));
28891 return resultobj;
28892 fail:
28893 return NULL;
28894 }
28895
28896
28897 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28898 PyObject *resultobj = 0;
28899 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28900 int result;
28901 void *argp1 = 0 ;
28902 int res1 = 0 ;
28903 PyObject *swig_obj[1] ;
28904
28905 if (!args) SWIG_fail;
28906 swig_obj[0] = args;
28907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28908 if (!SWIG_IsOK(res1)) {
28909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28910 }
28911 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 result = (int)(arg1)->GetKeyCode();
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 resultobj = SWIG_From_int(static_cast< int >(result));
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28926 PyObject *resultobj = 0;
28927 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28928 int result;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 PyObject *swig_obj[1] ;
28932
28933 if (!args) SWIG_fail;
28934 swig_obj[0] = args;
28935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28936 if (!SWIG_IsOK(res1)) {
28937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28938 }
28939 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 result = (int)(arg1)->GetCommand();
28943 wxPyEndAllowThreads(__tstate);
28944 if (PyErr_Occurred()) SWIG_fail;
28945 }
28946 resultobj = SWIG_From_int(static_cast< int >(result));
28947 return resultobj;
28948 fail:
28949 return NULL;
28950 }
28951
28952
28953 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28954 PyObject *obj;
28955 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28956 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28957 return SWIG_Py_Void();
28958 }
28959
28960 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28961 return SWIG_Python_InitShadowInstance(args);
28962 }
28963
28964 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28965 PyObject *resultobj = 0;
28966 int arg1 ;
28967 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28968 wxAcceleratorTable *result = 0 ;
28969 PyObject * obj0 = 0 ;
28970 char * kwnames[] = {
28971 (char *) "n", NULL
28972 };
28973
28974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28975 {
28976 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28977 if (arg2) arg1 = PyList_Size(obj0);
28978 else arg1 = 0;
28979 }
28980 {
28981 PyThreadState* __tstate = wxPyBeginAllowThreads();
28982 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28987 return resultobj;
28988 fail:
28989 return NULL;
28990 }
28991
28992
28993 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28994 PyObject *resultobj = 0;
28995 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28996 void *argp1 = 0 ;
28997 int res1 = 0 ;
28998 PyObject *swig_obj[1] ;
28999
29000 if (!args) SWIG_fail;
29001 swig_obj[0] = args;
29002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29003 if (!SWIG_IsOK(res1)) {
29004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29005 }
29006 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29007 {
29008 PyThreadState* __tstate = wxPyBeginAllowThreads();
29009 delete arg1;
29010
29011 wxPyEndAllowThreads(__tstate);
29012 if (PyErr_Occurred()) SWIG_fail;
29013 }
29014 resultobj = SWIG_Py_Void();
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29022 PyObject *resultobj = 0;
29023 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29024 bool result;
29025 void *argp1 = 0 ;
29026 int res1 = 0 ;
29027 PyObject *swig_obj[1] ;
29028
29029 if (!args) SWIG_fail;
29030 swig_obj[0] = args;
29031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29032 if (!SWIG_IsOK(res1)) {
29033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29034 }
29035 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 {
29043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29044 }
29045 return resultobj;
29046 fail:
29047 return NULL;
29048 }
29049
29050
29051 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 PyObject *obj;
29053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29054 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29055 return SWIG_Py_Void();
29056 }
29057
29058 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29059 return SWIG_Python_InitShadowInstance(args);
29060 }
29061
29062 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29063 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29064 return 1;
29065 }
29066
29067
29068 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29069 PyObject *pyobj = 0;
29070
29071 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29072 return pyobj;
29073 }
29074
29075
29076 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29077 PyObject *resultobj = 0;
29078 wxString *arg1 = 0 ;
29079 wxAcceleratorEntry *result = 0 ;
29080 bool temp1 = false ;
29081 PyObject * obj0 = 0 ;
29082 char * kwnames[] = {
29083 (char *) "label", NULL
29084 };
29085
29086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29087 {
29088 arg1 = wxString_in_helper(obj0);
29089 if (arg1 == NULL) SWIG_fail;
29090 temp1 = true;
29091 }
29092 {
29093 PyThreadState* __tstate = wxPyBeginAllowThreads();
29094 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29099 {
29100 if (temp1)
29101 delete arg1;
29102 }
29103 return resultobj;
29104 fail:
29105 {
29106 if (temp1)
29107 delete arg1;
29108 }
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN int PanelNameStr_set(PyObject *) {
29114 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29115 return 1;
29116 }
29117
29118
29119 SWIGINTERN PyObject *PanelNameStr_get(void) {
29120 PyObject *pyobj = 0;
29121
29122 {
29123 #if wxUSE_UNICODE
29124 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29125 #else
29126 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29127 #endif
29128 }
29129 return pyobj;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxVisualAttributes *result = 0 ;
29136
29137 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (wxVisualAttributes *)new_wxVisualAttributes();
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29145 return resultobj;
29146 fail:
29147 return NULL;
29148 }
29149
29150
29151 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 PyObject *resultobj = 0;
29153 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29154 void *argp1 = 0 ;
29155 int res1 = 0 ;
29156 PyObject *swig_obj[1] ;
29157
29158 if (!args) SWIG_fail;
29159 swig_obj[0] = args;
29160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29161 if (!SWIG_IsOK(res1)) {
29162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29163 }
29164 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 delete_wxVisualAttributes(arg1);
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 resultobj = SWIG_Py_Void();
29173 return resultobj;
29174 fail:
29175 return NULL;
29176 }
29177
29178
29179 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29180 PyObject *resultobj = 0;
29181 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29182 wxFont *arg2 = (wxFont *) 0 ;
29183 void *argp1 = 0 ;
29184 int res1 = 0 ;
29185 void *argp2 = 0 ;
29186 int res2 = 0 ;
29187 PyObject *swig_obj[2] ;
29188
29189 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29191 if (!SWIG_IsOK(res1)) {
29192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29193 }
29194 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29195 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29196 if (!SWIG_IsOK(res2)) {
29197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29198 }
29199 arg2 = reinterpret_cast< wxFont * >(argp2);
29200 if (arg1) (arg1)->font = *arg2;
29201
29202 resultobj = SWIG_Py_Void();
29203 return resultobj;
29204 fail:
29205 return NULL;
29206 }
29207
29208
29209 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29210 PyObject *resultobj = 0;
29211 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29212 wxFont *result = 0 ;
29213 void *argp1 = 0 ;
29214 int res1 = 0 ;
29215 PyObject *swig_obj[1] ;
29216
29217 if (!args) SWIG_fail;
29218 swig_obj[0] = args;
29219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29220 if (!SWIG_IsOK(res1)) {
29221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29222 }
29223 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29224 result = (wxFont *)& ((arg1)->font);
29225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29226 return resultobj;
29227 fail:
29228 return NULL;
29229 }
29230
29231
29232 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29233 PyObject *resultobj = 0;
29234 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29235 wxColour *arg2 = (wxColour *) 0 ;
29236 void *argp1 = 0 ;
29237 int res1 = 0 ;
29238 void *argp2 = 0 ;
29239 int res2 = 0 ;
29240 PyObject *swig_obj[2] ;
29241
29242 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29244 if (!SWIG_IsOK(res1)) {
29245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29246 }
29247 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29248 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29249 if (!SWIG_IsOK(res2)) {
29250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29251 }
29252 arg2 = reinterpret_cast< wxColour * >(argp2);
29253 if (arg1) (arg1)->colFg = *arg2;
29254
29255 resultobj = SWIG_Py_Void();
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29263 PyObject *resultobj = 0;
29264 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29265 wxColour *result = 0 ;
29266 void *argp1 = 0 ;
29267 int res1 = 0 ;
29268 PyObject *swig_obj[1] ;
29269
29270 if (!args) SWIG_fail;
29271 swig_obj[0] = args;
29272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29273 if (!SWIG_IsOK(res1)) {
29274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29275 }
29276 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29277 result = (wxColour *)& ((arg1)->colFg);
29278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29286 PyObject *resultobj = 0;
29287 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29288 wxColour *arg2 = (wxColour *) 0 ;
29289 void *argp1 = 0 ;
29290 int res1 = 0 ;
29291 void *argp2 = 0 ;
29292 int res2 = 0 ;
29293 PyObject *swig_obj[2] ;
29294
29295 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29297 if (!SWIG_IsOK(res1)) {
29298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29299 }
29300 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29301 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29302 if (!SWIG_IsOK(res2)) {
29303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29304 }
29305 arg2 = reinterpret_cast< wxColour * >(argp2);
29306 if (arg1) (arg1)->colBg = *arg2;
29307
29308 resultobj = SWIG_Py_Void();
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *resultobj = 0;
29317 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29318 wxColour *result = 0 ;
29319 void *argp1 = 0 ;
29320 int res1 = 0 ;
29321 PyObject *swig_obj[1] ;
29322
29323 if (!args) SWIG_fail;
29324 swig_obj[0] = args;
29325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29328 }
29329 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29330 result = (wxColour *)& ((arg1)->colBg);
29331 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29332 return resultobj;
29333 fail:
29334 return NULL;
29335 }
29336
29337
29338 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29339 PyObject *obj;
29340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29341 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29342 return SWIG_Py_Void();
29343 }
29344
29345 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29346 return SWIG_Python_InitShadowInstance(args);
29347 }
29348
29349 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29350 PyObject *resultobj = 0;
29351 wxWindow *arg1 = (wxWindow *) 0 ;
29352 int arg2 = (int) (int)-1 ;
29353 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29354 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29355 wxSize const &arg4_defvalue = wxDefaultSize ;
29356 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29357 long arg5 = (long) 0 ;
29358 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29359 wxString *arg6 = (wxString *) &arg6_defvalue ;
29360 wxWindow *result = 0 ;
29361 void *argp1 = 0 ;
29362 int res1 = 0 ;
29363 int val2 ;
29364 int ecode2 = 0 ;
29365 wxPoint temp3 ;
29366 wxSize temp4 ;
29367 long val5 ;
29368 int ecode5 = 0 ;
29369 bool temp6 = false ;
29370 PyObject * obj0 = 0 ;
29371 PyObject * obj1 = 0 ;
29372 PyObject * obj2 = 0 ;
29373 PyObject * obj3 = 0 ;
29374 PyObject * obj4 = 0 ;
29375 PyObject * obj5 = 0 ;
29376 char * kwnames[] = {
29377 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29378 };
29379
29380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29382 if (!SWIG_IsOK(res1)) {
29383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29384 }
29385 arg1 = reinterpret_cast< wxWindow * >(argp1);
29386 if (obj1) {
29387 ecode2 = SWIG_AsVal_int(obj1, &val2);
29388 if (!SWIG_IsOK(ecode2)) {
29389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29390 }
29391 arg2 = static_cast< int >(val2);
29392 }
29393 if (obj2) {
29394 {
29395 arg3 = &temp3;
29396 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29397 }
29398 }
29399 if (obj3) {
29400 {
29401 arg4 = &temp4;
29402 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29403 }
29404 }
29405 if (obj4) {
29406 ecode5 = SWIG_AsVal_long(obj4, &val5);
29407 if (!SWIG_IsOK(ecode5)) {
29408 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29409 }
29410 arg5 = static_cast< long >(val5);
29411 }
29412 if (obj5) {
29413 {
29414 arg6 = wxString_in_helper(obj5);
29415 if (arg6 == NULL) SWIG_fail;
29416 temp6 = true;
29417 }
29418 }
29419 {
29420 if (!wxPyCheckForApp()) SWIG_fail;
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29427 {
29428 if (temp6)
29429 delete arg6;
29430 }
29431 return resultobj;
29432 fail:
29433 {
29434 if (temp6)
29435 delete arg6;
29436 }
29437 return NULL;
29438 }
29439
29440
29441 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29442 PyObject *resultobj = 0;
29443 wxWindow *result = 0 ;
29444
29445 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29446 {
29447 if (!wxPyCheckForApp()) SWIG_fail;
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (wxWindow *)new wxWindow();
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29454 return resultobj;
29455 fail:
29456 return NULL;
29457 }
29458
29459
29460 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29461 PyObject *resultobj = 0;
29462 wxWindow *arg1 = (wxWindow *) 0 ;
29463 wxWindow *arg2 = (wxWindow *) 0 ;
29464 int arg3 = (int) (int)-1 ;
29465 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29466 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29467 wxSize const &arg5_defvalue = wxDefaultSize ;
29468 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29469 long arg6 = (long) 0 ;
29470 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29471 wxString *arg7 = (wxString *) &arg7_defvalue ;
29472 bool result;
29473 void *argp1 = 0 ;
29474 int res1 = 0 ;
29475 void *argp2 = 0 ;
29476 int res2 = 0 ;
29477 int val3 ;
29478 int ecode3 = 0 ;
29479 wxPoint temp4 ;
29480 wxSize temp5 ;
29481 long val6 ;
29482 int ecode6 = 0 ;
29483 bool temp7 = false ;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 PyObject * obj2 = 0 ;
29487 PyObject * obj3 = 0 ;
29488 PyObject * obj4 = 0 ;
29489 PyObject * obj5 = 0 ;
29490 PyObject * obj6 = 0 ;
29491 char * kwnames[] = {
29492 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29493 };
29494
29495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29497 if (!SWIG_IsOK(res1)) {
29498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29499 }
29500 arg1 = reinterpret_cast< wxWindow * >(argp1);
29501 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29502 if (!SWIG_IsOK(res2)) {
29503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29504 }
29505 arg2 = reinterpret_cast< wxWindow * >(argp2);
29506 if (obj2) {
29507 ecode3 = SWIG_AsVal_int(obj2, &val3);
29508 if (!SWIG_IsOK(ecode3)) {
29509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29510 }
29511 arg3 = static_cast< int >(val3);
29512 }
29513 if (obj3) {
29514 {
29515 arg4 = &temp4;
29516 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29517 }
29518 }
29519 if (obj4) {
29520 {
29521 arg5 = &temp5;
29522 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29523 }
29524 }
29525 if (obj5) {
29526 ecode6 = SWIG_AsVal_long(obj5, &val6);
29527 if (!SWIG_IsOK(ecode6)) {
29528 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29529 }
29530 arg6 = static_cast< long >(val6);
29531 }
29532 if (obj6) {
29533 {
29534 arg7 = wxString_in_helper(obj6);
29535 if (arg7 == NULL) SWIG_fail;
29536 temp7 = true;
29537 }
29538 }
29539 {
29540 PyThreadState* __tstate = wxPyBeginAllowThreads();
29541 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29542 wxPyEndAllowThreads(__tstate);
29543 if (PyErr_Occurred()) SWIG_fail;
29544 }
29545 {
29546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29547 }
29548 {
29549 if (temp7)
29550 delete arg7;
29551 }
29552 return resultobj;
29553 fail:
29554 {
29555 if (temp7)
29556 delete arg7;
29557 }
29558 return NULL;
29559 }
29560
29561
29562 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj = 0;
29564 wxWindow *arg1 = (wxWindow *) 0 ;
29565 bool arg2 = (bool) false ;
29566 bool result;
29567 void *argp1 = 0 ;
29568 int res1 = 0 ;
29569 bool val2 ;
29570 int ecode2 = 0 ;
29571 PyObject * obj0 = 0 ;
29572 PyObject * obj1 = 0 ;
29573 char * kwnames[] = {
29574 (char *) "self",(char *) "force", NULL
29575 };
29576
29577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29581 }
29582 arg1 = reinterpret_cast< wxWindow * >(argp1);
29583 if (obj1) {
29584 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29585 if (!SWIG_IsOK(ecode2)) {
29586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29587 }
29588 arg2 = static_cast< bool >(val2);
29589 }
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 result = (bool)(arg1)->Close(arg2);
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 {
29597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29598 }
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *resultobj = 0;
29607 wxWindow *arg1 = (wxWindow *) 0 ;
29608 bool result;
29609 void *argp1 = 0 ;
29610 int res1 = 0 ;
29611 PyObject *swig_obj[1] ;
29612
29613 if (!args) SWIG_fail;
29614 swig_obj[0] = args;
29615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29616 if (!SWIG_IsOK(res1)) {
29617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29618 }
29619 arg1 = reinterpret_cast< wxWindow * >(argp1);
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (bool)(arg1)->Destroy();
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 {
29627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29628 }
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxWindow *arg1 = (wxWindow *) 0 ;
29638 bool result;
29639 void *argp1 = 0 ;
29640 int res1 = 0 ;
29641 PyObject *swig_obj[1] ;
29642
29643 if (!args) SWIG_fail;
29644 swig_obj[0] = args;
29645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29648 }
29649 arg1 = reinterpret_cast< wxWindow * >(argp1);
29650 {
29651 PyThreadState* __tstate = wxPyBeginAllowThreads();
29652 result = (bool)(arg1)->DestroyChildren();
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 {
29657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29658 }
29659 return resultobj;
29660 fail:
29661 return NULL;
29662 }
29663
29664
29665 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29666 PyObject *resultobj = 0;
29667 wxWindow *arg1 = (wxWindow *) 0 ;
29668 bool result;
29669 void *argp1 = 0 ;
29670 int res1 = 0 ;
29671 PyObject *swig_obj[1] ;
29672
29673 if (!args) SWIG_fail;
29674 swig_obj[0] = args;
29675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29676 if (!SWIG_IsOK(res1)) {
29677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29678 }
29679 arg1 = reinterpret_cast< wxWindow * >(argp1);
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 {
29687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj = 0;
29697 wxWindow *arg1 = (wxWindow *) 0 ;
29698 wxString *arg2 = 0 ;
29699 void *argp1 = 0 ;
29700 int res1 = 0 ;
29701 bool temp2 = false ;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 char * kwnames[] = {
29705 (char *) "self",(char *) "label", NULL
29706 };
29707
29708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29710 if (!SWIG_IsOK(res1)) {
29711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29712 }
29713 arg1 = reinterpret_cast< wxWindow * >(argp1);
29714 {
29715 arg2 = wxString_in_helper(obj1);
29716 if (arg2 == NULL) SWIG_fail;
29717 temp2 = true;
29718 }
29719 {
29720 PyThreadState* __tstate = wxPyBeginAllowThreads();
29721 (arg1)->SetLabel((wxString const &)*arg2);
29722 wxPyEndAllowThreads(__tstate);
29723 if (PyErr_Occurred()) SWIG_fail;
29724 }
29725 resultobj = SWIG_Py_Void();
29726 {
29727 if (temp2)
29728 delete arg2;
29729 }
29730 return resultobj;
29731 fail:
29732 {
29733 if (temp2)
29734 delete arg2;
29735 }
29736 return NULL;
29737 }
29738
29739
29740 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29741 PyObject *resultobj = 0;
29742 wxWindow *arg1 = (wxWindow *) 0 ;
29743 wxString result;
29744 void *argp1 = 0 ;
29745 int res1 = 0 ;
29746 PyObject *swig_obj[1] ;
29747
29748 if (!args) SWIG_fail;
29749 swig_obj[0] = args;
29750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29751 if (!SWIG_IsOK(res1)) {
29752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29753 }
29754 arg1 = reinterpret_cast< wxWindow * >(argp1);
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 result = ((wxWindow const *)arg1)->GetLabel();
29758 wxPyEndAllowThreads(__tstate);
29759 if (PyErr_Occurred()) SWIG_fail;
29760 }
29761 {
29762 #if wxUSE_UNICODE
29763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29764 #else
29765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29766 #endif
29767 }
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj = 0;
29776 wxWindow *arg1 = (wxWindow *) 0 ;
29777 wxString *arg2 = 0 ;
29778 void *argp1 = 0 ;
29779 int res1 = 0 ;
29780 bool temp2 = false ;
29781 PyObject * obj0 = 0 ;
29782 PyObject * obj1 = 0 ;
29783 char * kwnames[] = {
29784 (char *) "self",(char *) "name", NULL
29785 };
29786
29787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29789 if (!SWIG_IsOK(res1)) {
29790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29791 }
29792 arg1 = reinterpret_cast< wxWindow * >(argp1);
29793 {
29794 arg2 = wxString_in_helper(obj1);
29795 if (arg2 == NULL) SWIG_fail;
29796 temp2 = true;
29797 }
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 (arg1)->SetName((wxString const &)*arg2);
29801 wxPyEndAllowThreads(__tstate);
29802 if (PyErr_Occurred()) SWIG_fail;
29803 }
29804 resultobj = SWIG_Py_Void();
29805 {
29806 if (temp2)
29807 delete arg2;
29808 }
29809 return resultobj;
29810 fail:
29811 {
29812 if (temp2)
29813 delete arg2;
29814 }
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 PyObject *resultobj = 0;
29821 wxWindow *arg1 = (wxWindow *) 0 ;
29822 wxString result;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 PyObject *swig_obj[1] ;
29826
29827 if (!args) SWIG_fail;
29828 swig_obj[0] = args;
29829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29832 }
29833 arg1 = reinterpret_cast< wxWindow * >(argp1);
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = ((wxWindow const *)arg1)->GetName();
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 {
29841 #if wxUSE_UNICODE
29842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29843 #else
29844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29845 #endif
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj = 0;
29855 wxWindow *arg1 = (wxWindow *) 0 ;
29856 wxWindowVariant arg2 ;
29857 void *argp1 = 0 ;
29858 int res1 = 0 ;
29859 int val2 ;
29860 int ecode2 = 0 ;
29861 PyObject * obj0 = 0 ;
29862 PyObject * obj1 = 0 ;
29863 char * kwnames[] = {
29864 (char *) "self",(char *) "variant", NULL
29865 };
29866
29867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29869 if (!SWIG_IsOK(res1)) {
29870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29871 }
29872 arg1 = reinterpret_cast< wxWindow * >(argp1);
29873 ecode2 = SWIG_AsVal_int(obj1, &val2);
29874 if (!SWIG_IsOK(ecode2)) {
29875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29876 }
29877 arg2 = static_cast< wxWindowVariant >(val2);
29878 {
29879 PyThreadState* __tstate = wxPyBeginAllowThreads();
29880 (arg1)->SetWindowVariant(arg2);
29881 wxPyEndAllowThreads(__tstate);
29882 if (PyErr_Occurred()) SWIG_fail;
29883 }
29884 resultobj = SWIG_Py_Void();
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxWindow *arg1 = (wxWindow *) 0 ;
29894 wxWindowVariant result;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 PyObject *swig_obj[1] ;
29898
29899 if (!args) SWIG_fail;
29900 swig_obj[0] = args;
29901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29904 }
29905 arg1 = reinterpret_cast< wxWindow * >(argp1);
29906 {
29907 PyThreadState* __tstate = wxPyBeginAllowThreads();
29908 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29909 wxPyEndAllowThreads(__tstate);
29910 if (PyErr_Occurred()) SWIG_fail;
29911 }
29912 resultobj = SWIG_From_int(static_cast< int >(result));
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj = 0;
29921 wxWindow *arg1 = (wxWindow *) 0 ;
29922 int arg2 ;
29923 void *argp1 = 0 ;
29924 int res1 = 0 ;
29925 int val2 ;
29926 int ecode2 = 0 ;
29927 PyObject * obj0 = 0 ;
29928 PyObject * obj1 = 0 ;
29929 char * kwnames[] = {
29930 (char *) "self",(char *) "winid", NULL
29931 };
29932
29933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29937 }
29938 arg1 = reinterpret_cast< wxWindow * >(argp1);
29939 ecode2 = SWIG_AsVal_int(obj1, &val2);
29940 if (!SWIG_IsOK(ecode2)) {
29941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29942 }
29943 arg2 = static_cast< int >(val2);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 (arg1)->SetId(arg2);
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 resultobj = SWIG_Py_Void();
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29958 PyObject *resultobj = 0;
29959 wxWindow *arg1 = (wxWindow *) 0 ;
29960 int result;
29961 void *argp1 = 0 ;
29962 int res1 = 0 ;
29963 PyObject *swig_obj[1] ;
29964
29965 if (!args) SWIG_fail;
29966 swig_obj[0] = args;
29967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29968 if (!SWIG_IsOK(res1)) {
29969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29970 }
29971 arg1 = reinterpret_cast< wxWindow * >(argp1);
29972 {
29973 PyThreadState* __tstate = wxPyBeginAllowThreads();
29974 result = (int)((wxWindow const *)arg1)->GetId();
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 resultobj = SWIG_From_int(static_cast< int >(result));
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29986 PyObject *resultobj = 0;
29987 int result;
29988
29989 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 result = (int)wxWindow::NewControlId();
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 resultobj = SWIG_From_int(static_cast< int >(result));
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj = 0;
30005 int arg1 ;
30006 int result;
30007 int val1 ;
30008 int ecode1 = 0 ;
30009 PyObject * obj0 = 0 ;
30010 char * kwnames[] = {
30011 (char *) "winid", NULL
30012 };
30013
30014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30015 ecode1 = SWIG_AsVal_int(obj0, &val1);
30016 if (!SWIG_IsOK(ecode1)) {
30017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30018 }
30019 arg1 = static_cast< int >(val1);
30020 {
30021 PyThreadState* __tstate = wxPyBeginAllowThreads();
30022 result = (int)wxWindow::NextControlId(arg1);
30023 wxPyEndAllowThreads(__tstate);
30024 if (PyErr_Occurred()) SWIG_fail;
30025 }
30026 resultobj = SWIG_From_int(static_cast< int >(result));
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30034 PyObject *resultobj = 0;
30035 int arg1 ;
30036 int result;
30037 int val1 ;
30038 int ecode1 = 0 ;
30039 PyObject * obj0 = 0 ;
30040 char * kwnames[] = {
30041 (char *) "winid", NULL
30042 };
30043
30044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30045 ecode1 = SWIG_AsVal_int(obj0, &val1);
30046 if (!SWIG_IsOK(ecode1)) {
30047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30048 }
30049 arg1 = static_cast< int >(val1);
30050 {
30051 PyThreadState* __tstate = wxPyBeginAllowThreads();
30052 result = (int)wxWindow::PrevControlId(arg1);
30053 wxPyEndAllowThreads(__tstate);
30054 if (PyErr_Occurred()) SWIG_fail;
30055 }
30056 resultobj = SWIG_From_int(static_cast< int >(result));
30057 return resultobj;
30058 fail:
30059 return NULL;
30060 }
30061
30062
30063 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30064 PyObject *resultobj = 0;
30065 wxWindow *arg1 = (wxWindow *) 0 ;
30066 wxSize *arg2 = 0 ;
30067 void *argp1 = 0 ;
30068 int res1 = 0 ;
30069 wxSize temp2 ;
30070 PyObject * obj0 = 0 ;
30071 PyObject * obj1 = 0 ;
30072 char * kwnames[] = {
30073 (char *) "self",(char *) "size", NULL
30074 };
30075
30076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30078 if (!SWIG_IsOK(res1)) {
30079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30080 }
30081 arg1 = reinterpret_cast< wxWindow * >(argp1);
30082 {
30083 arg2 = &temp2;
30084 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30085 }
30086 {
30087 PyThreadState* __tstate = wxPyBeginAllowThreads();
30088 (arg1)->SetSize((wxSize const &)*arg2);
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_Py_Void();
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30100 PyObject *resultobj = 0;
30101 wxWindow *arg1 = (wxWindow *) 0 ;
30102 int arg2 ;
30103 int arg3 ;
30104 int arg4 ;
30105 int arg5 ;
30106 int arg6 = (int) wxSIZE_AUTO ;
30107 void *argp1 = 0 ;
30108 int res1 = 0 ;
30109 int val2 ;
30110 int ecode2 = 0 ;
30111 int val3 ;
30112 int ecode3 = 0 ;
30113 int val4 ;
30114 int ecode4 = 0 ;
30115 int val5 ;
30116 int ecode5 = 0 ;
30117 int val6 ;
30118 int ecode6 = 0 ;
30119 PyObject * obj0 = 0 ;
30120 PyObject * obj1 = 0 ;
30121 PyObject * obj2 = 0 ;
30122 PyObject * obj3 = 0 ;
30123 PyObject * obj4 = 0 ;
30124 PyObject * obj5 = 0 ;
30125 char * kwnames[] = {
30126 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30127 };
30128
30129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30131 if (!SWIG_IsOK(res1)) {
30132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30133 }
30134 arg1 = reinterpret_cast< wxWindow * >(argp1);
30135 ecode2 = SWIG_AsVal_int(obj1, &val2);
30136 if (!SWIG_IsOK(ecode2)) {
30137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30138 }
30139 arg2 = static_cast< int >(val2);
30140 ecode3 = SWIG_AsVal_int(obj2, &val3);
30141 if (!SWIG_IsOK(ecode3)) {
30142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30143 }
30144 arg3 = static_cast< int >(val3);
30145 ecode4 = SWIG_AsVal_int(obj3, &val4);
30146 if (!SWIG_IsOK(ecode4)) {
30147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30148 }
30149 arg4 = static_cast< int >(val4);
30150 ecode5 = SWIG_AsVal_int(obj4, &val5);
30151 if (!SWIG_IsOK(ecode5)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30153 }
30154 arg5 = static_cast< int >(val5);
30155 if (obj5) {
30156 ecode6 = SWIG_AsVal_int(obj5, &val6);
30157 if (!SWIG_IsOK(ecode6)) {
30158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30159 }
30160 arg6 = static_cast< int >(val6);
30161 }
30162 {
30163 PyThreadState* __tstate = wxPyBeginAllowThreads();
30164 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30165 wxPyEndAllowThreads(__tstate);
30166 if (PyErr_Occurred()) SWIG_fail;
30167 }
30168 resultobj = SWIG_Py_Void();
30169 return resultobj;
30170 fail:
30171 return NULL;
30172 }
30173
30174
30175 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30176 PyObject *resultobj = 0;
30177 wxWindow *arg1 = (wxWindow *) 0 ;
30178 wxRect *arg2 = 0 ;
30179 int arg3 = (int) wxSIZE_AUTO ;
30180 void *argp1 = 0 ;
30181 int res1 = 0 ;
30182 wxRect temp2 ;
30183 int val3 ;
30184 int ecode3 = 0 ;
30185 PyObject * obj0 = 0 ;
30186 PyObject * obj1 = 0 ;
30187 PyObject * obj2 = 0 ;
30188 char * kwnames[] = {
30189 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30190 };
30191
30192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30194 if (!SWIG_IsOK(res1)) {
30195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30196 }
30197 arg1 = reinterpret_cast< wxWindow * >(argp1);
30198 {
30199 arg2 = &temp2;
30200 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30201 }
30202 if (obj2) {
30203 ecode3 = SWIG_AsVal_int(obj2, &val3);
30204 if (!SWIG_IsOK(ecode3)) {
30205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30206 }
30207 arg3 = static_cast< int >(val3);
30208 }
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 resultobj = SWIG_Py_Void();
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30223 PyObject *resultobj = 0;
30224 wxWindow *arg1 = (wxWindow *) 0 ;
30225 int arg2 ;
30226 int arg3 ;
30227 void *argp1 = 0 ;
30228 int res1 = 0 ;
30229 int val2 ;
30230 int ecode2 = 0 ;
30231 int val3 ;
30232 int ecode3 = 0 ;
30233 PyObject * obj0 = 0 ;
30234 PyObject * obj1 = 0 ;
30235 PyObject * obj2 = 0 ;
30236 char * kwnames[] = {
30237 (char *) "self",(char *) "width",(char *) "height", NULL
30238 };
30239
30240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30242 if (!SWIG_IsOK(res1)) {
30243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30244 }
30245 arg1 = reinterpret_cast< wxWindow * >(argp1);
30246 ecode2 = SWIG_AsVal_int(obj1, &val2);
30247 if (!SWIG_IsOK(ecode2)) {
30248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30249 }
30250 arg2 = static_cast< int >(val2);
30251 ecode3 = SWIG_AsVal_int(obj2, &val3);
30252 if (!SWIG_IsOK(ecode3)) {
30253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30254 }
30255 arg3 = static_cast< int >(val3);
30256 {
30257 PyThreadState* __tstate = wxPyBeginAllowThreads();
30258 (arg1)->SetSize(arg2,arg3);
30259 wxPyEndAllowThreads(__tstate);
30260 if (PyErr_Occurred()) SWIG_fail;
30261 }
30262 resultobj = SWIG_Py_Void();
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30270 PyObject *resultobj = 0;
30271 wxWindow *arg1 = (wxWindow *) 0 ;
30272 wxPoint *arg2 = 0 ;
30273 int arg3 = (int) wxSIZE_USE_EXISTING ;
30274 void *argp1 = 0 ;
30275 int res1 = 0 ;
30276 wxPoint temp2 ;
30277 int val3 ;
30278 int ecode3 = 0 ;
30279 PyObject * obj0 = 0 ;
30280 PyObject * obj1 = 0 ;
30281 PyObject * obj2 = 0 ;
30282 char * kwnames[] = {
30283 (char *) "self",(char *) "pt",(char *) "flags", NULL
30284 };
30285
30286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30288 if (!SWIG_IsOK(res1)) {
30289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30290 }
30291 arg1 = reinterpret_cast< wxWindow * >(argp1);
30292 {
30293 arg2 = &temp2;
30294 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30295 }
30296 if (obj2) {
30297 ecode3 = SWIG_AsVal_int(obj2, &val3);
30298 if (!SWIG_IsOK(ecode3)) {
30299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30300 }
30301 arg3 = static_cast< int >(val3);
30302 }
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 (arg1)->Move((wxPoint const &)*arg2,arg3);
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 resultobj = SWIG_Py_Void();
30310 return resultobj;
30311 fail:
30312 return NULL;
30313 }
30314
30315
30316 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30317 PyObject *resultobj = 0;
30318 wxWindow *arg1 = (wxWindow *) 0 ;
30319 int arg2 ;
30320 int arg3 ;
30321 int arg4 = (int) wxSIZE_USE_EXISTING ;
30322 void *argp1 = 0 ;
30323 int res1 = 0 ;
30324 int val2 ;
30325 int ecode2 = 0 ;
30326 int val3 ;
30327 int ecode3 = 0 ;
30328 int val4 ;
30329 int ecode4 = 0 ;
30330 PyObject * obj0 = 0 ;
30331 PyObject * obj1 = 0 ;
30332 PyObject * obj2 = 0 ;
30333 PyObject * obj3 = 0 ;
30334 char * kwnames[] = {
30335 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30336 };
30337
30338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30340 if (!SWIG_IsOK(res1)) {
30341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30342 }
30343 arg1 = reinterpret_cast< wxWindow * >(argp1);
30344 ecode2 = SWIG_AsVal_int(obj1, &val2);
30345 if (!SWIG_IsOK(ecode2)) {
30346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30347 }
30348 arg2 = static_cast< int >(val2);
30349 ecode3 = SWIG_AsVal_int(obj2, &val3);
30350 if (!SWIG_IsOK(ecode3)) {
30351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30352 }
30353 arg3 = static_cast< int >(val3);
30354 if (obj3) {
30355 ecode4 = SWIG_AsVal_int(obj3, &val4);
30356 if (!SWIG_IsOK(ecode4)) {
30357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30358 }
30359 arg4 = static_cast< int >(val4);
30360 }
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 (arg1)->Move(arg2,arg3,arg4);
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 resultobj = SWIG_Py_Void();
30368 return resultobj;
30369 fail:
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30375 PyObject *resultobj = 0;
30376 wxWindow *arg1 = (wxWindow *) 0 ;
30377 wxSize const &arg2_defvalue = wxDefaultSize ;
30378 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30379 void *argp1 = 0 ;
30380 int res1 = 0 ;
30381 wxSize temp2 ;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 char * kwnames[] = {
30385 (char *) "self",(char *) "size", NULL
30386 };
30387
30388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30392 }
30393 arg1 = reinterpret_cast< wxWindow * >(argp1);
30394 if (obj1) {
30395 {
30396 arg2 = &temp2;
30397 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30398 }
30399 }
30400 {
30401 PyThreadState* __tstate = wxPyBeginAllowThreads();
30402 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30403 wxPyEndAllowThreads(__tstate);
30404 if (PyErr_Occurred()) SWIG_fail;
30405 }
30406 resultobj = SWIG_Py_Void();
30407 return resultobj;
30408 fail:
30409 return NULL;
30410 }
30411
30412
30413 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30414 PyObject *resultobj = 0;
30415 wxWindow *arg1 = (wxWindow *) 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 PyObject *swig_obj[1] ;
30419
30420 if (!args) SWIG_fail;
30421 swig_obj[0] = args;
30422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30423 if (!SWIG_IsOK(res1)) {
30424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30425 }
30426 arg1 = reinterpret_cast< wxWindow * >(argp1);
30427 {
30428 PyThreadState* __tstate = wxPyBeginAllowThreads();
30429 (arg1)->Raise();
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 resultobj = SWIG_Py_Void();
30434 return resultobj;
30435 fail:
30436 return NULL;
30437 }
30438
30439
30440 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30441 PyObject *resultobj = 0;
30442 wxWindow *arg1 = (wxWindow *) 0 ;
30443 void *argp1 = 0 ;
30444 int res1 = 0 ;
30445 PyObject *swig_obj[1] ;
30446
30447 if (!args) SWIG_fail;
30448 swig_obj[0] = args;
30449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30450 if (!SWIG_IsOK(res1)) {
30451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30452 }
30453 arg1 = reinterpret_cast< wxWindow * >(argp1);
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
30456 (arg1)->Lower();
30457 wxPyEndAllowThreads(__tstate);
30458 if (PyErr_Occurred()) SWIG_fail;
30459 }
30460 resultobj = SWIG_Py_Void();
30461 return resultobj;
30462 fail:
30463 return NULL;
30464 }
30465
30466
30467 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30468 PyObject *resultobj = 0;
30469 wxWindow *arg1 = (wxWindow *) 0 ;
30470 wxSize *arg2 = 0 ;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 wxSize temp2 ;
30474 PyObject * obj0 = 0 ;
30475 PyObject * obj1 = 0 ;
30476 char * kwnames[] = {
30477 (char *) "self",(char *) "size", NULL
30478 };
30479
30480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30482 if (!SWIG_IsOK(res1)) {
30483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30484 }
30485 arg1 = reinterpret_cast< wxWindow * >(argp1);
30486 {
30487 arg2 = &temp2;
30488 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30489 }
30490 {
30491 PyThreadState* __tstate = wxPyBeginAllowThreads();
30492 (arg1)->SetClientSize((wxSize const &)*arg2);
30493 wxPyEndAllowThreads(__tstate);
30494 if (PyErr_Occurred()) SWIG_fail;
30495 }
30496 resultobj = SWIG_Py_Void();
30497 return resultobj;
30498 fail:
30499 return NULL;
30500 }
30501
30502
30503 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30504 PyObject *resultobj = 0;
30505 wxWindow *arg1 = (wxWindow *) 0 ;
30506 int arg2 ;
30507 int arg3 ;
30508 void *argp1 = 0 ;
30509 int res1 = 0 ;
30510 int val2 ;
30511 int ecode2 = 0 ;
30512 int val3 ;
30513 int ecode3 = 0 ;
30514 PyObject * obj0 = 0 ;
30515 PyObject * obj1 = 0 ;
30516 PyObject * obj2 = 0 ;
30517 char * kwnames[] = {
30518 (char *) "self",(char *) "width",(char *) "height", NULL
30519 };
30520
30521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30523 if (!SWIG_IsOK(res1)) {
30524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30525 }
30526 arg1 = reinterpret_cast< wxWindow * >(argp1);
30527 ecode2 = SWIG_AsVal_int(obj1, &val2);
30528 if (!SWIG_IsOK(ecode2)) {
30529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30530 }
30531 arg2 = static_cast< int >(val2);
30532 ecode3 = SWIG_AsVal_int(obj2, &val3);
30533 if (!SWIG_IsOK(ecode3)) {
30534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30535 }
30536 arg3 = static_cast< int >(val3);
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 (arg1)->SetClientSize(arg2,arg3);
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 resultobj = SWIG_Py_Void();
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj = 0;
30552 wxWindow *arg1 = (wxWindow *) 0 ;
30553 wxRect *arg2 = 0 ;
30554 void *argp1 = 0 ;
30555 int res1 = 0 ;
30556 wxRect temp2 ;
30557 PyObject * obj0 = 0 ;
30558 PyObject * obj1 = 0 ;
30559 char * kwnames[] = {
30560 (char *) "self",(char *) "rect", NULL
30561 };
30562
30563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30567 }
30568 arg1 = reinterpret_cast< wxWindow * >(argp1);
30569 {
30570 arg2 = &temp2;
30571 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30572 }
30573 {
30574 PyThreadState* __tstate = wxPyBeginAllowThreads();
30575 (arg1)->SetClientSize((wxRect 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_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxWindow *arg1 = (wxWindow *) 0 ;
30589 wxPoint result;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 PyObject *swig_obj[1] ;
30593
30594 if (!args) SWIG_fail;
30595 swig_obj[0] = args;
30596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30597 if (!SWIG_IsOK(res1)) {
30598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30599 }
30600 arg1 = reinterpret_cast< wxWindow * >(argp1);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 result = ((wxWindow const *)arg1)->GetPosition();
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxWindow *arg1 = (wxWindow *) 0 ;
30617 int *arg2 = (int *) 0 ;
30618 int *arg3 = (int *) 0 ;
30619 void *argp1 = 0 ;
30620 int res1 = 0 ;
30621 int temp2 ;
30622 int res2 = SWIG_TMPOBJ ;
30623 int temp3 ;
30624 int res3 = SWIG_TMPOBJ ;
30625 PyObject *swig_obj[1] ;
30626
30627 arg2 = &temp2;
30628 arg3 = &temp3;
30629 if (!args) SWIG_fail;
30630 swig_obj[0] = args;
30631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30632 if (!SWIG_IsOK(res1)) {
30633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30634 }
30635 arg1 = reinterpret_cast< wxWindow * >(argp1);
30636 {
30637 PyThreadState* __tstate = wxPyBeginAllowThreads();
30638 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30639 wxPyEndAllowThreads(__tstate);
30640 if (PyErr_Occurred()) SWIG_fail;
30641 }
30642 resultobj = SWIG_Py_Void();
30643 if (SWIG_IsTmpObj(res2)) {
30644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30645 } else {
30646 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30648 }
30649 if (SWIG_IsTmpObj(res3)) {
30650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30651 } else {
30652 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30654 }
30655 return resultobj;
30656 fail:
30657 return NULL;
30658 }
30659
30660
30661 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30662 PyObject *resultobj = 0;
30663 wxWindow *arg1 = (wxWindow *) 0 ;
30664 wxPoint result;
30665 void *argp1 = 0 ;
30666 int res1 = 0 ;
30667 PyObject *swig_obj[1] ;
30668
30669 if (!args) SWIG_fail;
30670 swig_obj[0] = args;
30671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30672 if (!SWIG_IsOK(res1)) {
30673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30674 }
30675 arg1 = reinterpret_cast< wxWindow * >(argp1);
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = ((wxWindow const *)arg1)->GetScreenPosition();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 int *arg2 = (int *) 0 ;
30693 int *arg3 = (int *) 0 ;
30694 void *argp1 = 0 ;
30695 int res1 = 0 ;
30696 int temp2 ;
30697 int res2 = SWIG_TMPOBJ ;
30698 int temp3 ;
30699 int res3 = SWIG_TMPOBJ ;
30700 PyObject *swig_obj[1] ;
30701
30702 arg2 = &temp2;
30703 arg3 = &temp3;
30704 if (!args) SWIG_fail;
30705 swig_obj[0] = args;
30706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30709 }
30710 arg1 = reinterpret_cast< wxWindow * >(argp1);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 resultobj = SWIG_Py_Void();
30718 if (SWIG_IsTmpObj(res2)) {
30719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30720 } else {
30721 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30723 }
30724 if (SWIG_IsTmpObj(res3)) {
30725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30726 } else {
30727 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30737 PyObject *resultobj = 0;
30738 wxWindow *arg1 = (wxWindow *) 0 ;
30739 wxRect result;
30740 void *argp1 = 0 ;
30741 int res1 = 0 ;
30742 PyObject *swig_obj[1] ;
30743
30744 if (!args) SWIG_fail;
30745 swig_obj[0] = args;
30746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30749 }
30750 arg1 = reinterpret_cast< wxWindow * >(argp1);
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = ((wxWindow const *)arg1)->GetScreenRect();
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30765 PyObject *resultobj = 0;
30766 wxWindow *arg1 = (wxWindow *) 0 ;
30767 wxSize result;
30768 void *argp1 = 0 ;
30769 int res1 = 0 ;
30770 PyObject *swig_obj[1] ;
30771
30772 if (!args) SWIG_fail;
30773 swig_obj[0] = args;
30774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30775 if (!SWIG_IsOK(res1)) {
30776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30777 }
30778 arg1 = reinterpret_cast< wxWindow * >(argp1);
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = ((wxWindow const *)arg1)->GetSize();
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30793 PyObject *resultobj = 0;
30794 wxWindow *arg1 = (wxWindow *) 0 ;
30795 int *arg2 = (int *) 0 ;
30796 int *arg3 = (int *) 0 ;
30797 void *argp1 = 0 ;
30798 int res1 = 0 ;
30799 int temp2 ;
30800 int res2 = SWIG_TMPOBJ ;
30801 int temp3 ;
30802 int res3 = SWIG_TMPOBJ ;
30803 PyObject *swig_obj[1] ;
30804
30805 arg2 = &temp2;
30806 arg3 = &temp3;
30807 if (!args) SWIG_fail;
30808 swig_obj[0] = args;
30809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30810 if (!SWIG_IsOK(res1)) {
30811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30812 }
30813 arg1 = reinterpret_cast< wxWindow * >(argp1);
30814 {
30815 PyThreadState* __tstate = wxPyBeginAllowThreads();
30816 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30817 wxPyEndAllowThreads(__tstate);
30818 if (PyErr_Occurred()) SWIG_fail;
30819 }
30820 resultobj = SWIG_Py_Void();
30821 if (SWIG_IsTmpObj(res2)) {
30822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30823 } else {
30824 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30826 }
30827 if (SWIG_IsTmpObj(res3)) {
30828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30829 } else {
30830 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxWindow *arg1 = (wxWindow *) 0 ;
30842 wxRect result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxWindow * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = ((wxWindow const *)arg1)->GetRect();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30868 PyObject *resultobj = 0;
30869 wxWindow *arg1 = (wxWindow *) 0 ;
30870 wxSize result;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 PyObject *swig_obj[1] ;
30874
30875 if (!args) SWIG_fail;
30876 swig_obj[0] = args;
30877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30878 if (!SWIG_IsOK(res1)) {
30879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30880 }
30881 arg1 = reinterpret_cast< wxWindow * >(argp1);
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = ((wxWindow const *)arg1)->GetClientSize();
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30889 return resultobj;
30890 fail:
30891 return NULL;
30892 }
30893
30894
30895 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30896 PyObject *resultobj = 0;
30897 wxWindow *arg1 = (wxWindow *) 0 ;
30898 int *arg2 = (int *) 0 ;
30899 int *arg3 = (int *) 0 ;
30900 void *argp1 = 0 ;
30901 int res1 = 0 ;
30902 int temp2 ;
30903 int res2 = SWIG_TMPOBJ ;
30904 int temp3 ;
30905 int res3 = SWIG_TMPOBJ ;
30906 PyObject *swig_obj[1] ;
30907
30908 arg2 = &temp2;
30909 arg3 = &temp3;
30910 if (!args) SWIG_fail;
30911 swig_obj[0] = args;
30912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30913 if (!SWIG_IsOK(res1)) {
30914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30915 }
30916 arg1 = reinterpret_cast< wxWindow * >(argp1);
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30920 wxPyEndAllowThreads(__tstate);
30921 if (PyErr_Occurred()) SWIG_fail;
30922 }
30923 resultobj = SWIG_Py_Void();
30924 if (SWIG_IsTmpObj(res2)) {
30925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30926 } else {
30927 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30929 }
30930 if (SWIG_IsTmpObj(res3)) {
30931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30932 } else {
30933 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30935 }
30936 return resultobj;
30937 fail:
30938 return NULL;
30939 }
30940
30941
30942 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30943 PyObject *resultobj = 0;
30944 wxWindow *arg1 = (wxWindow *) 0 ;
30945 wxPoint result;
30946 void *argp1 = 0 ;
30947 int res1 = 0 ;
30948 PyObject *swig_obj[1] ;
30949
30950 if (!args) SWIG_fail;
30951 swig_obj[0] = args;
30952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30955 }
30956 arg1 = reinterpret_cast< wxWindow * >(argp1);
30957 {
30958 PyThreadState* __tstate = wxPyBeginAllowThreads();
30959 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30971 PyObject *resultobj = 0;
30972 wxWindow *arg1 = (wxWindow *) 0 ;
30973 wxRect result;
30974 void *argp1 = 0 ;
30975 int res1 = 0 ;
30976 PyObject *swig_obj[1] ;
30977
30978 if (!args) SWIG_fail;
30979 swig_obj[0] = args;
30980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30981 if (!SWIG_IsOK(res1)) {
30982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30983 }
30984 arg1 = reinterpret_cast< wxWindow * >(argp1);
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 result = ((wxWindow const *)arg1)->GetClientRect();
30988 wxPyEndAllowThreads(__tstate);
30989 if (PyErr_Occurred()) SWIG_fail;
30990 }
30991 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30992 return resultobj;
30993 fail:
30994 return NULL;
30995 }
30996
30997
30998 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30999 PyObject *resultobj = 0;
31000 wxWindow *arg1 = (wxWindow *) 0 ;
31001 wxSize result;
31002 void *argp1 = 0 ;
31003 int res1 = 0 ;
31004 PyObject *swig_obj[1] ;
31005
31006 if (!args) SWIG_fail;
31007 swig_obj[0] = args;
31008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31009 if (!SWIG_IsOK(res1)) {
31010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31011 }
31012 arg1 = reinterpret_cast< wxWindow * >(argp1);
31013 {
31014 PyThreadState* __tstate = wxPyBeginAllowThreads();
31015 result = ((wxWindow const *)arg1)->GetBestSize();
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31027 PyObject *resultobj = 0;
31028 wxWindow *arg1 = (wxWindow *) 0 ;
31029 int *arg2 = (int *) 0 ;
31030 int *arg3 = (int *) 0 ;
31031 void *argp1 = 0 ;
31032 int res1 = 0 ;
31033 int temp2 ;
31034 int res2 = SWIG_TMPOBJ ;
31035 int temp3 ;
31036 int res3 = SWIG_TMPOBJ ;
31037 PyObject *swig_obj[1] ;
31038
31039 arg2 = &temp2;
31040 arg3 = &temp3;
31041 if (!args) SWIG_fail;
31042 swig_obj[0] = args;
31043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31044 if (!SWIG_IsOK(res1)) {
31045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31046 }
31047 arg1 = reinterpret_cast< wxWindow * >(argp1);
31048 {
31049 PyThreadState* __tstate = wxPyBeginAllowThreads();
31050 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31051 wxPyEndAllowThreads(__tstate);
31052 if (PyErr_Occurred()) SWIG_fail;
31053 }
31054 resultobj = SWIG_Py_Void();
31055 if (SWIG_IsTmpObj(res2)) {
31056 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31057 } else {
31058 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31060 }
31061 if (SWIG_IsTmpObj(res3)) {
31062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31063 } else {
31064 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31066 }
31067 return resultobj;
31068 fail:
31069 return NULL;
31070 }
31071
31072
31073 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31074 PyObject *resultobj = 0;
31075 wxWindow *arg1 = (wxWindow *) 0 ;
31076 void *argp1 = 0 ;
31077 int res1 = 0 ;
31078 PyObject *swig_obj[1] ;
31079
31080 if (!args) SWIG_fail;
31081 swig_obj[0] = args;
31082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31083 if (!SWIG_IsOK(res1)) {
31084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31085 }
31086 arg1 = reinterpret_cast< wxWindow * >(argp1);
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 (arg1)->InvalidateBestSize();
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 resultobj = SWIG_Py_Void();
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj = 0;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 wxSize *arg2 = 0 ;
31104 void *argp1 = 0 ;
31105 int res1 = 0 ;
31106 wxSize temp2 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "size", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 {
31120 arg2 = &temp2;
31121 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31122 }
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_Py_Void();
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxWindow *arg1 = (wxWindow *) 0 ;
31139 wxSize result;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31149 }
31150 arg1 = reinterpret_cast< wxWindow * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31165 PyObject *resultobj = 0;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 wxSize result;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 PyObject *swig_obj[1] ;
31171
31172 if (!args) SWIG_fail;
31173 swig_obj[0] = args;
31174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31175 if (!SWIG_IsOK(res1)) {
31176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31177 }
31178 arg1 = reinterpret_cast< wxWindow * >(argp1);
31179 {
31180 PyThreadState* __tstate = wxPyBeginAllowThreads();
31181 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31182 wxPyEndAllowThreads(__tstate);
31183 if (PyErr_Occurred()) SWIG_fail;
31184 }
31185 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj = 0;
31194 wxWindow *arg1 = (wxWindow *) 0 ;
31195 int arg2 = (int) wxBOTH ;
31196 void *argp1 = 0 ;
31197 int res1 = 0 ;
31198 int val2 ;
31199 int ecode2 = 0 ;
31200 PyObject * obj0 = 0 ;
31201 PyObject * obj1 = 0 ;
31202 char * kwnames[] = {
31203 (char *) "self",(char *) "direction", NULL
31204 };
31205
31206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31208 if (!SWIG_IsOK(res1)) {
31209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31210 }
31211 arg1 = reinterpret_cast< wxWindow * >(argp1);
31212 if (obj1) {
31213 ecode2 = SWIG_AsVal_int(obj1, &val2);
31214 if (!SWIG_IsOK(ecode2)) {
31215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31216 }
31217 arg2 = static_cast< int >(val2);
31218 }
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 (arg1)->Center(arg2);
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_Py_Void();
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 wxWindow *arg1 = (wxWindow *) 0 ;
31235 int arg2 = (int) wxBOTH ;
31236 void *argp1 = 0 ;
31237 int res1 = 0 ;
31238 int val2 ;
31239 int ecode2 = 0 ;
31240 PyObject * obj0 = 0 ;
31241 PyObject * obj1 = 0 ;
31242 char * kwnames[] = {
31243 (char *) "self",(char *) "dir", NULL
31244 };
31245
31246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31248 if (!SWIG_IsOK(res1)) {
31249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31250 }
31251 arg1 = reinterpret_cast< wxWindow * >(argp1);
31252 if (obj1) {
31253 ecode2 = SWIG_AsVal_int(obj1, &val2);
31254 if (!SWIG_IsOK(ecode2)) {
31255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31256 }
31257 arg2 = static_cast< int >(val2);
31258 }
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 (arg1)->CenterOnParent(arg2);
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_Py_Void();
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31273 PyObject *resultobj = 0;
31274 wxWindow *arg1 = (wxWindow *) 0 ;
31275 void *argp1 = 0 ;
31276 int res1 = 0 ;
31277 PyObject *swig_obj[1] ;
31278
31279 if (!args) SWIG_fail;
31280 swig_obj[0] = args;
31281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31282 if (!SWIG_IsOK(res1)) {
31283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31284 }
31285 arg1 = reinterpret_cast< wxWindow * >(argp1);
31286 {
31287 PyThreadState* __tstate = wxPyBeginAllowThreads();
31288 (arg1)->Fit();
31289 wxPyEndAllowThreads(__tstate);
31290 if (PyErr_Occurred()) SWIG_fail;
31291 }
31292 resultobj = SWIG_Py_Void();
31293 return resultobj;
31294 fail:
31295 return NULL;
31296 }
31297
31298
31299 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31300 PyObject *resultobj = 0;
31301 wxWindow *arg1 = (wxWindow *) 0 ;
31302 void *argp1 = 0 ;
31303 int res1 = 0 ;
31304 PyObject *swig_obj[1] ;
31305
31306 if (!args) SWIG_fail;
31307 swig_obj[0] = args;
31308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31309 if (!SWIG_IsOK(res1)) {
31310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31311 }
31312 arg1 = reinterpret_cast< wxWindow * >(argp1);
31313 {
31314 PyThreadState* __tstate = wxPyBeginAllowThreads();
31315 (arg1)->FitInside();
31316 wxPyEndAllowThreads(__tstate);
31317 if (PyErr_Occurred()) SWIG_fail;
31318 }
31319 resultobj = SWIG_Py_Void();
31320 return resultobj;
31321 fail:
31322 return NULL;
31323 }
31324
31325
31326 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31327 PyObject *resultobj = 0;
31328 wxWindow *arg1 = (wxWindow *) 0 ;
31329 int arg2 ;
31330 int arg3 ;
31331 int arg4 = (int) -1 ;
31332 int arg5 = (int) -1 ;
31333 int arg6 = (int) -1 ;
31334 int arg7 = (int) -1 ;
31335 void *argp1 = 0 ;
31336 int res1 = 0 ;
31337 int val2 ;
31338 int ecode2 = 0 ;
31339 int val3 ;
31340 int ecode3 = 0 ;
31341 int val4 ;
31342 int ecode4 = 0 ;
31343 int val5 ;
31344 int ecode5 = 0 ;
31345 int val6 ;
31346 int ecode6 = 0 ;
31347 int val7 ;
31348 int ecode7 = 0 ;
31349 PyObject * obj0 = 0 ;
31350 PyObject * obj1 = 0 ;
31351 PyObject * obj2 = 0 ;
31352 PyObject * obj3 = 0 ;
31353 PyObject * obj4 = 0 ;
31354 PyObject * obj5 = 0 ;
31355 PyObject * obj6 = 0 ;
31356 char * kwnames[] = {
31357 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31358 };
31359
31360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31364 }
31365 arg1 = reinterpret_cast< wxWindow * >(argp1);
31366 ecode2 = SWIG_AsVal_int(obj1, &val2);
31367 if (!SWIG_IsOK(ecode2)) {
31368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31369 }
31370 arg2 = static_cast< int >(val2);
31371 ecode3 = SWIG_AsVal_int(obj2, &val3);
31372 if (!SWIG_IsOK(ecode3)) {
31373 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31374 }
31375 arg3 = static_cast< int >(val3);
31376 if (obj3) {
31377 ecode4 = SWIG_AsVal_int(obj3, &val4);
31378 if (!SWIG_IsOK(ecode4)) {
31379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31380 }
31381 arg4 = static_cast< int >(val4);
31382 }
31383 if (obj4) {
31384 ecode5 = SWIG_AsVal_int(obj4, &val5);
31385 if (!SWIG_IsOK(ecode5)) {
31386 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31387 }
31388 arg5 = static_cast< int >(val5);
31389 }
31390 if (obj5) {
31391 ecode6 = SWIG_AsVal_int(obj5, &val6);
31392 if (!SWIG_IsOK(ecode6)) {
31393 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31394 }
31395 arg6 = static_cast< int >(val6);
31396 }
31397 if (obj6) {
31398 ecode7 = SWIG_AsVal_int(obj6, &val7);
31399 if (!SWIG_IsOK(ecode7)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31401 }
31402 arg7 = static_cast< int >(val7);
31403 }
31404 {
31405 PyThreadState* __tstate = wxPyBeginAllowThreads();
31406 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 resultobj = SWIG_Py_Void();
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31418 PyObject *resultobj = 0;
31419 wxWindow *arg1 = (wxWindow *) 0 ;
31420 wxSize *arg2 = 0 ;
31421 wxSize const &arg3_defvalue = wxDefaultSize ;
31422 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31423 wxSize const &arg4_defvalue = wxDefaultSize ;
31424 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31425 void *argp1 = 0 ;
31426 int res1 = 0 ;
31427 wxSize temp2 ;
31428 wxSize temp3 ;
31429 wxSize temp4 ;
31430 PyObject * obj0 = 0 ;
31431 PyObject * obj1 = 0 ;
31432 PyObject * obj2 = 0 ;
31433 PyObject * obj3 = 0 ;
31434 char * kwnames[] = {
31435 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31436 };
31437
31438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31440 if (!SWIG_IsOK(res1)) {
31441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31442 }
31443 arg1 = reinterpret_cast< wxWindow * >(argp1);
31444 {
31445 arg2 = &temp2;
31446 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31447 }
31448 if (obj2) {
31449 {
31450 arg3 = &temp3;
31451 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31452 }
31453 }
31454 if (obj3) {
31455 {
31456 arg4 = &temp4;
31457 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31458 }
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_Py_Void();
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31474 PyObject *resultobj = 0;
31475 wxWindow *arg1 = (wxWindow *) 0 ;
31476 int arg2 ;
31477 int arg3 ;
31478 int arg4 = (int) -1 ;
31479 int arg5 = (int) -1 ;
31480 void *argp1 = 0 ;
31481 int res1 = 0 ;
31482 int val2 ;
31483 int ecode2 = 0 ;
31484 int val3 ;
31485 int ecode3 = 0 ;
31486 int val4 ;
31487 int ecode4 = 0 ;
31488 int val5 ;
31489 int ecode5 = 0 ;
31490 PyObject * obj0 = 0 ;
31491 PyObject * obj1 = 0 ;
31492 PyObject * obj2 = 0 ;
31493 PyObject * obj3 = 0 ;
31494 PyObject * obj4 = 0 ;
31495 char * kwnames[] = {
31496 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31497 };
31498
31499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31501 if (!SWIG_IsOK(res1)) {
31502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31503 }
31504 arg1 = reinterpret_cast< wxWindow * >(argp1);
31505 ecode2 = SWIG_AsVal_int(obj1, &val2);
31506 if (!SWIG_IsOK(ecode2)) {
31507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31508 }
31509 arg2 = static_cast< int >(val2);
31510 ecode3 = SWIG_AsVal_int(obj2, &val3);
31511 if (!SWIG_IsOK(ecode3)) {
31512 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31513 }
31514 arg3 = static_cast< int >(val3);
31515 if (obj3) {
31516 ecode4 = SWIG_AsVal_int(obj3, &val4);
31517 if (!SWIG_IsOK(ecode4)) {
31518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31519 }
31520 arg4 = static_cast< int >(val4);
31521 }
31522 if (obj4) {
31523 ecode5 = SWIG_AsVal_int(obj4, &val5);
31524 if (!SWIG_IsOK(ecode5)) {
31525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31526 }
31527 arg5 = static_cast< int >(val5);
31528 }
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 resultobj = SWIG_Py_Void();
31536 return resultobj;
31537 fail:
31538 return NULL;
31539 }
31540
31541
31542 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31543 PyObject *resultobj = 0;
31544 wxWindow *arg1 = (wxWindow *) 0 ;
31545 wxSize *arg2 = 0 ;
31546 wxSize const &arg3_defvalue = wxDefaultSize ;
31547 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 wxSize temp2 ;
31551 wxSize temp3 ;
31552 PyObject * obj0 = 0 ;
31553 PyObject * obj1 = 0 ;
31554 PyObject * obj2 = 0 ;
31555 char * kwnames[] = {
31556 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31557 };
31558
31559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31561 if (!SWIG_IsOK(res1)) {
31562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31563 }
31564 arg1 = reinterpret_cast< wxWindow * >(argp1);
31565 {
31566 arg2 = &temp2;
31567 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31568 }
31569 if (obj2) {
31570 {
31571 arg3 = &temp3;
31572 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31573 }
31574 }
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_Py_Void();
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *resultobj = 0;
31590 wxWindow *arg1 = (wxWindow *) 0 ;
31591 wxSize result;
31592 void *argp1 = 0 ;
31593 int res1 = 0 ;
31594 PyObject *swig_obj[1] ;
31595
31596 if (!args) SWIG_fail;
31597 swig_obj[0] = args;
31598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31599 if (!SWIG_IsOK(res1)) {
31600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31601 }
31602 arg1 = reinterpret_cast< wxWindow * >(argp1);
31603 {
31604 PyThreadState* __tstate = wxPyBeginAllowThreads();
31605 result = ((wxWindow const *)arg1)->GetMaxSize();
31606 wxPyEndAllowThreads(__tstate);
31607 if (PyErr_Occurred()) SWIG_fail;
31608 }
31609 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31610 return resultobj;
31611 fail:
31612 return NULL;
31613 }
31614
31615
31616 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31617 PyObject *resultobj = 0;
31618 wxWindow *arg1 = (wxWindow *) 0 ;
31619 wxSize result;
31620 void *argp1 = 0 ;
31621 int res1 = 0 ;
31622 PyObject *swig_obj[1] ;
31623
31624 if (!args) SWIG_fail;
31625 swig_obj[0] = args;
31626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31627 if (!SWIG_IsOK(res1)) {
31628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31629 }
31630 arg1 = reinterpret_cast< wxWindow * >(argp1);
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 result = ((wxWindow const *)arg1)->GetMinSize();
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31645 PyObject *resultobj = 0;
31646 wxWindow *arg1 = (wxWindow *) 0 ;
31647 wxSize *arg2 = 0 ;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 wxSize temp2 ;
31651 PyObject * obj0 = 0 ;
31652 PyObject * obj1 = 0 ;
31653 char * kwnames[] = {
31654 (char *) "self",(char *) "minSize", NULL
31655 };
31656
31657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31659 if (!SWIG_IsOK(res1)) {
31660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31661 }
31662 arg1 = reinterpret_cast< wxWindow * >(argp1);
31663 {
31664 arg2 = &temp2;
31665 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31666 }
31667 {
31668 PyThreadState* __tstate = wxPyBeginAllowThreads();
31669 (arg1)->SetMinSize((wxSize const &)*arg2);
31670 wxPyEndAllowThreads(__tstate);
31671 if (PyErr_Occurred()) SWIG_fail;
31672 }
31673 resultobj = SWIG_Py_Void();
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj = 0;
31682 wxWindow *arg1 = (wxWindow *) 0 ;
31683 wxSize *arg2 = 0 ;
31684 void *argp1 = 0 ;
31685 int res1 = 0 ;
31686 wxSize temp2 ;
31687 PyObject * obj0 = 0 ;
31688 PyObject * obj1 = 0 ;
31689 char * kwnames[] = {
31690 (char *) "self",(char *) "maxSize", NULL
31691 };
31692
31693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31695 if (!SWIG_IsOK(res1)) {
31696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31697 }
31698 arg1 = reinterpret_cast< wxWindow * >(argp1);
31699 {
31700 arg2 = &temp2;
31701 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31702 }
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 (arg1)->SetMaxSize((wxSize const &)*arg2);
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_Py_Void();
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxWindow *arg1 = (wxWindow *) 0 ;
31719 int result;
31720 void *argp1 = 0 ;
31721 int res1 = 0 ;
31722 PyObject *swig_obj[1] ;
31723
31724 if (!args) SWIG_fail;
31725 swig_obj[0] = args;
31726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31727 if (!SWIG_IsOK(res1)) {
31728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31729 }
31730 arg1 = reinterpret_cast< wxWindow * >(argp1);
31731 {
31732 PyThreadState* __tstate = wxPyBeginAllowThreads();
31733 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31734 wxPyEndAllowThreads(__tstate);
31735 if (PyErr_Occurred()) SWIG_fail;
31736 }
31737 resultobj = SWIG_From_int(static_cast< int >(result));
31738 return resultobj;
31739 fail:
31740 return NULL;
31741 }
31742
31743
31744 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31745 PyObject *resultobj = 0;
31746 wxWindow *arg1 = (wxWindow *) 0 ;
31747 int result;
31748 void *argp1 = 0 ;
31749 int res1 = 0 ;
31750 PyObject *swig_obj[1] ;
31751
31752 if (!args) SWIG_fail;
31753 swig_obj[0] = args;
31754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31755 if (!SWIG_IsOK(res1)) {
31756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31757 }
31758 arg1 = reinterpret_cast< wxWindow * >(argp1);
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31762 wxPyEndAllowThreads(__tstate);
31763 if (PyErr_Occurred()) SWIG_fail;
31764 }
31765 resultobj = SWIG_From_int(static_cast< int >(result));
31766 return resultobj;
31767 fail:
31768 return NULL;
31769 }
31770
31771
31772 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31773 PyObject *resultobj = 0;
31774 wxWindow *arg1 = (wxWindow *) 0 ;
31775 int result;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 PyObject *swig_obj[1] ;
31779
31780 if (!args) SWIG_fail;
31781 swig_obj[0] = args;
31782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31783 if (!SWIG_IsOK(res1)) {
31784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31785 }
31786 arg1 = reinterpret_cast< wxWindow * >(argp1);
31787 {
31788 PyThreadState* __tstate = wxPyBeginAllowThreads();
31789 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 resultobj = SWIG_From_int(static_cast< int >(result));
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 PyObject *resultobj = 0;
31802 wxWindow *arg1 = (wxWindow *) 0 ;
31803 int result;
31804 void *argp1 = 0 ;
31805 int res1 = 0 ;
31806 PyObject *swig_obj[1] ;
31807
31808 if (!args) SWIG_fail;
31809 swig_obj[0] = args;
31810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31811 if (!SWIG_IsOK(res1)) {
31812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31813 }
31814 arg1 = reinterpret_cast< wxWindow * >(argp1);
31815 {
31816 PyThreadState* __tstate = wxPyBeginAllowThreads();
31817 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 resultobj = SWIG_From_int(static_cast< int >(result));
31822 return resultobj;
31823 fail:
31824 return NULL;
31825 }
31826
31827
31828 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31829 PyObject *resultobj = 0;
31830 wxWindow *arg1 = (wxWindow *) 0 ;
31831 wxSize *arg2 = 0 ;
31832 void *argp1 = 0 ;
31833 int res1 = 0 ;
31834 wxSize temp2 ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 char * kwnames[] = {
31838 (char *) "self",(char *) "size", NULL
31839 };
31840
31841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31843 if (!SWIG_IsOK(res1)) {
31844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31845 }
31846 arg1 = reinterpret_cast< wxWindow * >(argp1);
31847 {
31848 arg2 = &temp2;
31849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31850 }
31851 {
31852 PyThreadState* __tstate = wxPyBeginAllowThreads();
31853 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31854 wxPyEndAllowThreads(__tstate);
31855 if (PyErr_Occurred()) SWIG_fail;
31856 }
31857 resultobj = SWIG_Py_Void();
31858 return resultobj;
31859 fail:
31860 return NULL;
31861 }
31862
31863
31864 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31865 PyObject *resultobj = 0;
31866 wxWindow *arg1 = (wxWindow *) 0 ;
31867 int arg2 ;
31868 int arg3 ;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 int val2 ;
31872 int ecode2 = 0 ;
31873 int val3 ;
31874 int ecode3 = 0 ;
31875 PyObject * obj0 = 0 ;
31876 PyObject * obj1 = 0 ;
31877 PyObject * obj2 = 0 ;
31878 char * kwnames[] = {
31879 (char *) "self",(char *) "w",(char *) "h", NULL
31880 };
31881
31882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31884 if (!SWIG_IsOK(res1)) {
31885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31886 }
31887 arg1 = reinterpret_cast< wxWindow * >(argp1);
31888 ecode2 = SWIG_AsVal_int(obj1, &val2);
31889 if (!SWIG_IsOK(ecode2)) {
31890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31891 }
31892 arg2 = static_cast< int >(val2);
31893 ecode3 = SWIG_AsVal_int(obj2, &val3);
31894 if (!SWIG_IsOK(ecode3)) {
31895 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31896 }
31897 arg3 = static_cast< int >(val3);
31898 {
31899 PyThreadState* __tstate = wxPyBeginAllowThreads();
31900 (arg1)->SetVirtualSize(arg2,arg3);
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 resultobj = SWIG_Py_Void();
31905 return resultobj;
31906 fail:
31907 return NULL;
31908 }
31909
31910
31911 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31912 PyObject *resultobj = 0;
31913 wxWindow *arg1 = (wxWindow *) 0 ;
31914 wxSize result;
31915 void *argp1 = 0 ;
31916 int res1 = 0 ;
31917 PyObject *swig_obj[1] ;
31918
31919 if (!args) SWIG_fail;
31920 swig_obj[0] = args;
31921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31922 if (!SWIG_IsOK(res1)) {
31923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31924 }
31925 arg1 = reinterpret_cast< wxWindow * >(argp1);
31926 {
31927 PyThreadState* __tstate = wxPyBeginAllowThreads();
31928 result = ((wxWindow const *)arg1)->GetVirtualSize();
31929 wxPyEndAllowThreads(__tstate);
31930 if (PyErr_Occurred()) SWIG_fail;
31931 }
31932 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31933 return resultobj;
31934 fail:
31935 return NULL;
31936 }
31937
31938
31939 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31940 PyObject *resultobj = 0;
31941 wxWindow *arg1 = (wxWindow *) 0 ;
31942 int *arg2 = (int *) 0 ;
31943 int *arg3 = (int *) 0 ;
31944 void *argp1 = 0 ;
31945 int res1 = 0 ;
31946 int temp2 ;
31947 int res2 = SWIG_TMPOBJ ;
31948 int temp3 ;
31949 int res3 = SWIG_TMPOBJ ;
31950 PyObject *swig_obj[1] ;
31951
31952 arg2 = &temp2;
31953 arg3 = &temp3;
31954 if (!args) SWIG_fail;
31955 swig_obj[0] = args;
31956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31957 if (!SWIG_IsOK(res1)) {
31958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31959 }
31960 arg1 = reinterpret_cast< wxWindow * >(argp1);
31961 {
31962 PyThreadState* __tstate = wxPyBeginAllowThreads();
31963 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31964 wxPyEndAllowThreads(__tstate);
31965 if (PyErr_Occurred()) SWIG_fail;
31966 }
31967 resultobj = SWIG_Py_Void();
31968 if (SWIG_IsTmpObj(res2)) {
31969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31970 } else {
31971 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31973 }
31974 if (SWIG_IsTmpObj(res3)) {
31975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31976 } else {
31977 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31979 }
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 PyObject *resultobj = 0;
31988 wxWindow *arg1 = (wxWindow *) 0 ;
31989 wxSize result;
31990 void *argp1 = 0 ;
31991 int res1 = 0 ;
31992 PyObject *swig_obj[1] ;
31993
31994 if (!args) SWIG_fail;
31995 swig_obj[0] = args;
31996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31997 if (!SWIG_IsOK(res1)) {
31998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31999 }
32000 arg1 = reinterpret_cast< wxWindow * >(argp1);
32001 {
32002 PyThreadState* __tstate = wxPyBeginAllowThreads();
32003 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32004 wxPyEndAllowThreads(__tstate);
32005 if (PyErr_Occurred()) SWIG_fail;
32006 }
32007 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32008 return resultobj;
32009 fail:
32010 return NULL;
32011 }
32012
32013
32014 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32015 PyObject *resultobj = 0;
32016 wxWindow *arg1 = (wxWindow *) 0 ;
32017 bool arg2 = (bool) true ;
32018 bool result;
32019 void *argp1 = 0 ;
32020 int res1 = 0 ;
32021 bool val2 ;
32022 int ecode2 = 0 ;
32023 PyObject * obj0 = 0 ;
32024 PyObject * obj1 = 0 ;
32025 char * kwnames[] = {
32026 (char *) "self",(char *) "show", NULL
32027 };
32028
32029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32031 if (!SWIG_IsOK(res1)) {
32032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32033 }
32034 arg1 = reinterpret_cast< wxWindow * >(argp1);
32035 if (obj1) {
32036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32037 if (!SWIG_IsOK(ecode2)) {
32038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32039 }
32040 arg2 = static_cast< bool >(val2);
32041 }
32042 {
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 result = (bool)(arg1)->Show(arg2);
32045 wxPyEndAllowThreads(__tstate);
32046 if (PyErr_Occurred()) SWIG_fail;
32047 }
32048 {
32049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32050 }
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 PyObject *resultobj = 0;
32059 wxWindow *arg1 = (wxWindow *) 0 ;
32060 bool result;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 PyObject *swig_obj[1] ;
32064
32065 if (!args) SWIG_fail;
32066 swig_obj[0] = args;
32067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32068 if (!SWIG_IsOK(res1)) {
32069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32070 }
32071 arg1 = reinterpret_cast< wxWindow * >(argp1);
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = (bool)(arg1)->Hide();
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 {
32079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32080 }
32081 return resultobj;
32082 fail:
32083 return NULL;
32084 }
32085
32086
32087 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32088 PyObject *resultobj = 0;
32089 wxWindow *arg1 = (wxWindow *) 0 ;
32090 bool arg2 = (bool) true ;
32091 bool result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 bool val2 ;
32095 int ecode2 = 0 ;
32096 PyObject * obj0 = 0 ;
32097 PyObject * obj1 = 0 ;
32098 char * kwnames[] = {
32099 (char *) "self",(char *) "enable", NULL
32100 };
32101
32102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32106 }
32107 arg1 = reinterpret_cast< wxWindow * >(argp1);
32108 if (obj1) {
32109 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32110 if (!SWIG_IsOK(ecode2)) {
32111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32112 }
32113 arg2 = static_cast< bool >(val2);
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (bool)(arg1)->Enable(arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 {
32122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32123 }
32124 return resultobj;
32125 fail:
32126 return NULL;
32127 }
32128
32129
32130 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32131 PyObject *resultobj = 0;
32132 wxWindow *arg1 = (wxWindow *) 0 ;
32133 bool result;
32134 void *argp1 = 0 ;
32135 int res1 = 0 ;
32136 PyObject *swig_obj[1] ;
32137
32138 if (!args) SWIG_fail;
32139 swig_obj[0] = args;
32140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32141 if (!SWIG_IsOK(res1)) {
32142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32143 }
32144 arg1 = reinterpret_cast< wxWindow * >(argp1);
32145 {
32146 PyThreadState* __tstate = wxPyBeginAllowThreads();
32147 result = (bool)(arg1)->Disable();
32148 wxPyEndAllowThreads(__tstate);
32149 if (PyErr_Occurred()) SWIG_fail;
32150 }
32151 {
32152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32153 }
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 bool result;
32164 void *argp1 = 0 ;
32165 int res1 = 0 ;
32166 PyObject *swig_obj[1] ;
32167
32168 if (!args) SWIG_fail;
32169 swig_obj[0] = args;
32170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32171 if (!SWIG_IsOK(res1)) {
32172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32173 }
32174 arg1 = reinterpret_cast< wxWindow * >(argp1);
32175 {
32176 PyThreadState* __tstate = wxPyBeginAllowThreads();
32177 result = (bool)((wxWindow const *)arg1)->IsShown();
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 {
32182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32183 }
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32191 PyObject *resultobj = 0;
32192 wxWindow *arg1 = (wxWindow *) 0 ;
32193 bool result;
32194 void *argp1 = 0 ;
32195 int res1 = 0 ;
32196 PyObject *swig_obj[1] ;
32197
32198 if (!args) SWIG_fail;
32199 swig_obj[0] = args;
32200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32201 if (!SWIG_IsOK(res1)) {
32202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32203 }
32204 arg1 = reinterpret_cast< wxWindow * >(argp1);
32205 {
32206 PyThreadState* __tstate = wxPyBeginAllowThreads();
32207 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32208 wxPyEndAllowThreads(__tstate);
32209 if (PyErr_Occurred()) SWIG_fail;
32210 }
32211 {
32212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32213 }
32214 return resultobj;
32215 fail:
32216 return NULL;
32217 }
32218
32219
32220 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32221 PyObject *resultobj = 0;
32222 wxWindow *arg1 = (wxWindow *) 0 ;
32223 long arg2 ;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 long val2 ;
32227 int ecode2 = 0 ;
32228 PyObject * obj0 = 0 ;
32229 PyObject * obj1 = 0 ;
32230 char * kwnames[] = {
32231 (char *) "self",(char *) "style", NULL
32232 };
32233
32234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32236 if (!SWIG_IsOK(res1)) {
32237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32238 }
32239 arg1 = reinterpret_cast< wxWindow * >(argp1);
32240 ecode2 = SWIG_AsVal_long(obj1, &val2);
32241 if (!SWIG_IsOK(ecode2)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32243 }
32244 arg2 = static_cast< long >(val2);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 (arg1)->SetWindowStyleFlag(arg2);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_Py_Void();
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32259 PyObject *resultobj = 0;
32260 wxWindow *arg1 = (wxWindow *) 0 ;
32261 long result;
32262 void *argp1 = 0 ;
32263 int res1 = 0 ;
32264 PyObject *swig_obj[1] ;
32265
32266 if (!args) SWIG_fail;
32267 swig_obj[0] = args;
32268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32269 if (!SWIG_IsOK(res1)) {
32270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32271 }
32272 arg1 = reinterpret_cast< wxWindow * >(argp1);
32273 {
32274 PyThreadState* __tstate = wxPyBeginAllowThreads();
32275 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32276 wxPyEndAllowThreads(__tstate);
32277 if (PyErr_Occurred()) SWIG_fail;
32278 }
32279 resultobj = SWIG_From_long(static_cast< long >(result));
32280 return resultobj;
32281 fail:
32282 return NULL;
32283 }
32284
32285
32286 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32287 PyObject *resultobj = 0;
32288 wxWindow *arg1 = (wxWindow *) 0 ;
32289 int arg2 ;
32290 bool result;
32291 void *argp1 = 0 ;
32292 int res1 = 0 ;
32293 int val2 ;
32294 int ecode2 = 0 ;
32295 PyObject * obj0 = 0 ;
32296 PyObject * obj1 = 0 ;
32297 char * kwnames[] = {
32298 (char *) "self",(char *) "flag", NULL
32299 };
32300
32301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32303 if (!SWIG_IsOK(res1)) {
32304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32305 }
32306 arg1 = reinterpret_cast< wxWindow * >(argp1);
32307 ecode2 = SWIG_AsVal_int(obj1, &val2);
32308 if (!SWIG_IsOK(ecode2)) {
32309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32310 }
32311 arg2 = static_cast< int >(val2);
32312 {
32313 PyThreadState* __tstate = wxPyBeginAllowThreads();
32314 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32315 wxPyEndAllowThreads(__tstate);
32316 if (PyErr_Occurred()) SWIG_fail;
32317 }
32318 {
32319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32320 }
32321 return resultobj;
32322 fail:
32323 return NULL;
32324 }
32325
32326
32327 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32328 PyObject *resultobj = 0;
32329 wxWindow *arg1 = (wxWindow *) 0 ;
32330 bool result;
32331 void *argp1 = 0 ;
32332 int res1 = 0 ;
32333 PyObject *swig_obj[1] ;
32334
32335 if (!args) SWIG_fail;
32336 swig_obj[0] = args;
32337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32338 if (!SWIG_IsOK(res1)) {
32339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32340 }
32341 arg1 = reinterpret_cast< wxWindow * >(argp1);
32342 {
32343 PyThreadState* __tstate = wxPyBeginAllowThreads();
32344 result = (bool)((wxWindow const *)arg1)->IsRetained();
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 {
32349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32350 }
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32358 PyObject *resultobj = 0;
32359 wxWindow *arg1 = (wxWindow *) 0 ;
32360 long arg2 ;
32361 void *argp1 = 0 ;
32362 int res1 = 0 ;
32363 long val2 ;
32364 int ecode2 = 0 ;
32365 PyObject * obj0 = 0 ;
32366 PyObject * obj1 = 0 ;
32367 char * kwnames[] = {
32368 (char *) "self",(char *) "exStyle", NULL
32369 };
32370
32371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32373 if (!SWIG_IsOK(res1)) {
32374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32375 }
32376 arg1 = reinterpret_cast< wxWindow * >(argp1);
32377 ecode2 = SWIG_AsVal_long(obj1, &val2);
32378 if (!SWIG_IsOK(ecode2)) {
32379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32380 }
32381 arg2 = static_cast< long >(val2);
32382 {
32383 PyThreadState* __tstate = wxPyBeginAllowThreads();
32384 (arg1)->SetExtraStyle(arg2);
32385 wxPyEndAllowThreads(__tstate);
32386 if (PyErr_Occurred()) SWIG_fail;
32387 }
32388 resultobj = SWIG_Py_Void();
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32396 PyObject *resultobj = 0;
32397 wxWindow *arg1 = (wxWindow *) 0 ;
32398 long result;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 PyObject *swig_obj[1] ;
32402
32403 if (!args) SWIG_fail;
32404 swig_obj[0] = args;
32405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32406 if (!SWIG_IsOK(res1)) {
32407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32408 }
32409 arg1 = reinterpret_cast< wxWindow * >(argp1);
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 resultobj = SWIG_From_long(static_cast< long >(result));
32417 return resultobj;
32418 fail:
32419 return NULL;
32420 }
32421
32422
32423 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32424 PyObject *resultobj = 0;
32425 wxWindow *arg1 = (wxWindow *) 0 ;
32426 bool arg2 = (bool) true ;
32427 void *argp1 = 0 ;
32428 int res1 = 0 ;
32429 bool val2 ;
32430 int ecode2 = 0 ;
32431 PyObject * obj0 = 0 ;
32432 PyObject * obj1 = 0 ;
32433 char * kwnames[] = {
32434 (char *) "self",(char *) "modal", NULL
32435 };
32436
32437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32439 if (!SWIG_IsOK(res1)) {
32440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32441 }
32442 arg1 = reinterpret_cast< wxWindow * >(argp1);
32443 if (obj1) {
32444 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32445 if (!SWIG_IsOK(ecode2)) {
32446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32447 }
32448 arg2 = static_cast< bool >(val2);
32449 }
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 (arg1)->MakeModal(arg2);
32453 wxPyEndAllowThreads(__tstate);
32454 if (PyErr_Occurred()) SWIG_fail;
32455 }
32456 resultobj = SWIG_Py_Void();
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32464 PyObject *resultobj = 0;
32465 wxWindow *arg1 = (wxWindow *) 0 ;
32466 bool arg2 ;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 bool val2 ;
32470 int ecode2 = 0 ;
32471 PyObject * obj0 = 0 ;
32472 PyObject * obj1 = 0 ;
32473 char * kwnames[] = {
32474 (char *) "self",(char *) "enableTheme", NULL
32475 };
32476
32477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32479 if (!SWIG_IsOK(res1)) {
32480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32481 }
32482 arg1 = reinterpret_cast< wxWindow * >(argp1);
32483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32484 if (!SWIG_IsOK(ecode2)) {
32485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32486 }
32487 arg2 = static_cast< bool >(val2);
32488 {
32489 PyThreadState* __tstate = wxPyBeginAllowThreads();
32490 (arg1)->SetThemeEnabled(arg2);
32491 wxPyEndAllowThreads(__tstate);
32492 if (PyErr_Occurred()) SWIG_fail;
32493 }
32494 resultobj = SWIG_Py_Void();
32495 return resultobj;
32496 fail:
32497 return NULL;
32498 }
32499
32500
32501 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32502 PyObject *resultobj = 0;
32503 wxWindow *arg1 = (wxWindow *) 0 ;
32504 bool result;
32505 void *argp1 = 0 ;
32506 int res1 = 0 ;
32507 PyObject *swig_obj[1] ;
32508
32509 if (!args) SWIG_fail;
32510 swig_obj[0] = args;
32511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32514 }
32515 arg1 = reinterpret_cast< wxWindow * >(argp1);
32516 {
32517 PyThreadState* __tstate = wxPyBeginAllowThreads();
32518 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 {
32523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32524 }
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxWindow *arg1 = (wxWindow *) 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32543 }
32544 arg1 = reinterpret_cast< wxWindow * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 (arg1)->SetFocus();
32548 wxPyEndAllowThreads(__tstate);
32549 if (PyErr_Occurred()) SWIG_fail;
32550 }
32551 resultobj = SWIG_Py_Void();
32552 return resultobj;
32553 fail:
32554 return NULL;
32555 }
32556
32557
32558 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32559 PyObject *resultobj = 0;
32560 wxWindow *arg1 = (wxWindow *) 0 ;
32561 void *argp1 = 0 ;
32562 int res1 = 0 ;
32563 PyObject *swig_obj[1] ;
32564
32565 if (!args) SWIG_fail;
32566 swig_obj[0] = args;
32567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32568 if (!SWIG_IsOK(res1)) {
32569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32570 }
32571 arg1 = reinterpret_cast< wxWindow * >(argp1);
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 (arg1)->SetFocusFromKbd();
32575 wxPyEndAllowThreads(__tstate);
32576 if (PyErr_Occurred()) SWIG_fail;
32577 }
32578 resultobj = SWIG_Py_Void();
32579 return resultobj;
32580 fail:
32581 return NULL;
32582 }
32583
32584
32585 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32586 PyObject *resultobj = 0;
32587 wxWindow *result = 0 ;
32588
32589 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32590 {
32591 if (!wxPyCheckForApp()) SWIG_fail;
32592 PyThreadState* __tstate = wxPyBeginAllowThreads();
32593 result = (wxWindow *)wxWindow::FindFocus();
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 {
32598 resultobj = wxPyMake_wxObject(result, 0);
32599 }
32600 return resultobj;
32601 fail:
32602 return NULL;
32603 }
32604
32605
32606 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32607 PyObject *resultobj = 0;
32608 wxWindow *arg1 = (wxWindow *) 0 ;
32609 bool result;
32610 void *argp1 = 0 ;
32611 int res1 = 0 ;
32612 PyObject *swig_obj[1] ;
32613
32614 if (!args) SWIG_fail;
32615 swig_obj[0] = args;
32616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32619 }
32620 arg1 = reinterpret_cast< wxWindow * >(argp1);
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 {
32628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32629 }
32630 return resultobj;
32631 fail:
32632 return NULL;
32633 }
32634
32635
32636 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32637 PyObject *resultobj = 0;
32638 wxWindow *arg1 = (wxWindow *) 0 ;
32639 bool result;
32640 void *argp1 = 0 ;
32641 int res1 = 0 ;
32642 PyObject *swig_obj[1] ;
32643
32644 if (!args) SWIG_fail;
32645 swig_obj[0] = args;
32646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32647 if (!SWIG_IsOK(res1)) {
32648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32649 }
32650 arg1 = reinterpret_cast< wxWindow * >(argp1);
32651 {
32652 PyThreadState* __tstate = wxPyBeginAllowThreads();
32653 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32654 wxPyEndAllowThreads(__tstate);
32655 if (PyErr_Occurred()) SWIG_fail;
32656 }
32657 {
32658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32659 }
32660 return resultobj;
32661 fail:
32662 return NULL;
32663 }
32664
32665
32666 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32667 PyObject *resultobj = 0;
32668 wxWindow *arg1 = (wxWindow *) 0 ;
32669 wxWindow *result = 0 ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 {
32688 resultobj = wxPyMake_wxObject(result, 0);
32689 }
32690 return resultobj;
32691 fail:
32692 return NULL;
32693 }
32694
32695
32696 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32697 PyObject *resultobj = 0;
32698 wxWindow *arg1 = (wxWindow *) 0 ;
32699 wxWindow *arg2 = (wxWindow *) 0 ;
32700 wxWindow *result = 0 ;
32701 void *argp1 = 0 ;
32702 int res1 = 0 ;
32703 void *argp2 = 0 ;
32704 int res2 = 0 ;
32705 PyObject * obj0 = 0 ;
32706 PyObject * obj1 = 0 ;
32707 char * kwnames[] = {
32708 (char *) "self",(char *) "child", NULL
32709 };
32710
32711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32713 if (!SWIG_IsOK(res1)) {
32714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32715 }
32716 arg1 = reinterpret_cast< wxWindow * >(argp1);
32717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32718 if (!SWIG_IsOK(res2)) {
32719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32720 }
32721 arg2 = reinterpret_cast< wxWindow * >(argp2);
32722 {
32723 PyThreadState* __tstate = wxPyBeginAllowThreads();
32724 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 {
32729 resultobj = wxPyMake_wxObject(result, 0);
32730 }
32731 return resultobj;
32732 fail:
32733 return NULL;
32734 }
32735
32736
32737 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32738 PyObject *resultobj = 0;
32739 wxWindow *arg1 = (wxWindow *) 0 ;
32740 wxWindow *arg2 = (wxWindow *) 0 ;
32741 void *argp1 = 0 ;
32742 int res1 = 0 ;
32743 void *argp2 = 0 ;
32744 int res2 = 0 ;
32745 PyObject * obj0 = 0 ;
32746 PyObject * obj1 = 0 ;
32747 char * kwnames[] = {
32748 (char *) "self",(char *) "win", NULL
32749 };
32750
32751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32753 if (!SWIG_IsOK(res1)) {
32754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32755 }
32756 arg1 = reinterpret_cast< wxWindow * >(argp1);
32757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32758 if (!SWIG_IsOK(res2)) {
32759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32760 }
32761 arg2 = reinterpret_cast< wxWindow * >(argp2);
32762 {
32763 PyThreadState* __tstate = wxPyBeginAllowThreads();
32764 (arg1)->SetTmpDefaultItem(arg2);
32765 wxPyEndAllowThreads(__tstate);
32766 if (PyErr_Occurred()) SWIG_fail;
32767 }
32768 resultobj = SWIG_Py_Void();
32769 return resultobj;
32770 fail:
32771 return NULL;
32772 }
32773
32774
32775 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32776 PyObject *resultobj = 0;
32777 wxWindow *arg1 = (wxWindow *) 0 ;
32778 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32779 bool result;
32780 void *argp1 = 0 ;
32781 int res1 = 0 ;
32782 int val2 ;
32783 int ecode2 = 0 ;
32784 PyObject * obj0 = 0 ;
32785 PyObject * obj1 = 0 ;
32786 char * kwnames[] = {
32787 (char *) "self",(char *) "flags", NULL
32788 };
32789
32790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32792 if (!SWIG_IsOK(res1)) {
32793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32794 }
32795 arg1 = reinterpret_cast< wxWindow * >(argp1);
32796 if (obj1) {
32797 ecode2 = SWIG_AsVal_int(obj1, &val2);
32798 if (!SWIG_IsOK(ecode2)) {
32799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32800 }
32801 arg2 = static_cast< int >(val2);
32802 }
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (bool)(arg1)->Navigate(arg2);
32806 wxPyEndAllowThreads(__tstate);
32807 if (PyErr_Occurred()) SWIG_fail;
32808 }
32809 {
32810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32811 }
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32819 PyObject *resultobj = 0;
32820 wxWindow *arg1 = (wxWindow *) 0 ;
32821 wxWindow *arg2 = (wxWindow *) 0 ;
32822 void *argp1 = 0 ;
32823 int res1 = 0 ;
32824 void *argp2 = 0 ;
32825 int res2 = 0 ;
32826 PyObject * obj0 = 0 ;
32827 PyObject * obj1 = 0 ;
32828 char * kwnames[] = {
32829 (char *) "self",(char *) "win", NULL
32830 };
32831
32832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32834 if (!SWIG_IsOK(res1)) {
32835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32836 }
32837 arg1 = reinterpret_cast< wxWindow * >(argp1);
32838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32839 if (!SWIG_IsOK(res2)) {
32840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32841 }
32842 arg2 = reinterpret_cast< wxWindow * >(argp2);
32843 {
32844 PyThreadState* __tstate = wxPyBeginAllowThreads();
32845 (arg1)->MoveAfterInTabOrder(arg2);
32846 wxPyEndAllowThreads(__tstate);
32847 if (PyErr_Occurred()) SWIG_fail;
32848 }
32849 resultobj = SWIG_Py_Void();
32850 return resultobj;
32851 fail:
32852 return NULL;
32853 }
32854
32855
32856 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32857 PyObject *resultobj = 0;
32858 wxWindow *arg1 = (wxWindow *) 0 ;
32859 wxWindow *arg2 = (wxWindow *) 0 ;
32860 void *argp1 = 0 ;
32861 int res1 = 0 ;
32862 void *argp2 = 0 ;
32863 int res2 = 0 ;
32864 PyObject * obj0 = 0 ;
32865 PyObject * obj1 = 0 ;
32866 char * kwnames[] = {
32867 (char *) "self",(char *) "win", NULL
32868 };
32869
32870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32872 if (!SWIG_IsOK(res1)) {
32873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32874 }
32875 arg1 = reinterpret_cast< wxWindow * >(argp1);
32876 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32877 if (!SWIG_IsOK(res2)) {
32878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32879 }
32880 arg2 = reinterpret_cast< wxWindow * >(argp2);
32881 {
32882 PyThreadState* __tstate = wxPyBeginAllowThreads();
32883 (arg1)->MoveBeforeInTabOrder(arg2);
32884 wxPyEndAllowThreads(__tstate);
32885 if (PyErr_Occurred()) SWIG_fail;
32886 }
32887 resultobj = SWIG_Py_Void();
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32895 PyObject *resultobj = 0;
32896 wxWindow *arg1 = (wxWindow *) 0 ;
32897 PyObject *result = 0 ;
32898 void *argp1 = 0 ;
32899 int res1 = 0 ;
32900 PyObject *swig_obj[1] ;
32901
32902 if (!args) SWIG_fail;
32903 swig_obj[0] = args;
32904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 {
32910 PyThreadState* __tstate = wxPyBeginAllowThreads();
32911 result = (PyObject *)wxWindow_GetChildren(arg1);
32912 wxPyEndAllowThreads(__tstate);
32913 if (PyErr_Occurred()) SWIG_fail;
32914 }
32915 resultobj = result;
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32923 PyObject *resultobj = 0;
32924 wxWindow *arg1 = (wxWindow *) 0 ;
32925 wxWindow *result = 0 ;
32926 void *argp1 = 0 ;
32927 int res1 = 0 ;
32928 PyObject *swig_obj[1] ;
32929
32930 if (!args) SWIG_fail;
32931 swig_obj[0] = args;
32932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32933 if (!SWIG_IsOK(res1)) {
32934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32935 }
32936 arg1 = reinterpret_cast< wxWindow * >(argp1);
32937 {
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32940 wxPyEndAllowThreads(__tstate);
32941 if (PyErr_Occurred()) SWIG_fail;
32942 }
32943 {
32944 resultobj = wxPyMake_wxObject(result, 0);
32945 }
32946 return resultobj;
32947 fail:
32948 return NULL;
32949 }
32950
32951
32952 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32953 PyObject *resultobj = 0;
32954 wxWindow *arg1 = (wxWindow *) 0 ;
32955 wxWindow *result = 0 ;
32956 void *argp1 = 0 ;
32957 int res1 = 0 ;
32958 PyObject *swig_obj[1] ;
32959
32960 if (!args) SWIG_fail;
32961 swig_obj[0] = args;
32962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32963 if (!SWIG_IsOK(res1)) {
32964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32965 }
32966 arg1 = reinterpret_cast< wxWindow * >(argp1);
32967 {
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 {
32974 resultobj = wxPyMake_wxObject(result, 0);
32975 }
32976 return resultobj;
32977 fail:
32978 return NULL;
32979 }
32980
32981
32982 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32983 PyObject *resultobj = 0;
32984 wxWindow *arg1 = (wxWindow *) 0 ;
32985 bool result;
32986 void *argp1 = 0 ;
32987 int res1 = 0 ;
32988 PyObject *swig_obj[1] ;
32989
32990 if (!args) SWIG_fail;
32991 swig_obj[0] = args;
32992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32993 if (!SWIG_IsOK(res1)) {
32994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32995 }
32996 arg1 = reinterpret_cast< wxWindow * >(argp1);
32997 {
32998 PyThreadState* __tstate = wxPyBeginAllowThreads();
32999 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 {
33004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33005 }
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 wxWindow *arg2 = (wxWindow *) 0 ;
33016 bool result;
33017 void *argp1 = 0 ;
33018 int res1 = 0 ;
33019 void *argp2 = 0 ;
33020 int res2 = 0 ;
33021 PyObject * obj0 = 0 ;
33022 PyObject * obj1 = 0 ;
33023 char * kwnames[] = {
33024 (char *) "self",(char *) "newParent", NULL
33025 };
33026
33027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33029 if (!SWIG_IsOK(res1)) {
33030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33031 }
33032 arg1 = reinterpret_cast< wxWindow * >(argp1);
33033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33034 if (!SWIG_IsOK(res2)) {
33035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33036 }
33037 arg2 = reinterpret_cast< wxWindow * >(argp2);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (bool)(arg1)->Reparent(arg2);
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 {
33045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33046 }
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33054 PyObject *resultobj = 0;
33055 wxWindow *arg1 = (wxWindow *) 0 ;
33056 wxWindow *arg2 = (wxWindow *) 0 ;
33057 void *argp1 = 0 ;
33058 int res1 = 0 ;
33059 void *argp2 = 0 ;
33060 int res2 = 0 ;
33061 PyObject * obj0 = 0 ;
33062 PyObject * obj1 = 0 ;
33063 char * kwnames[] = {
33064 (char *) "self",(char *) "child", NULL
33065 };
33066
33067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33069 if (!SWIG_IsOK(res1)) {
33070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33071 }
33072 arg1 = reinterpret_cast< wxWindow * >(argp1);
33073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33074 if (!SWIG_IsOK(res2)) {
33075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33076 }
33077 arg2 = reinterpret_cast< wxWindow * >(argp2);
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 (arg1)->AddChild(arg2);
33081 wxPyEndAllowThreads(__tstate);
33082 if (PyErr_Occurred()) SWIG_fail;
33083 }
33084 resultobj = SWIG_Py_Void();
33085 return resultobj;
33086 fail:
33087 return NULL;
33088 }
33089
33090
33091 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33092 PyObject *resultobj = 0;
33093 wxWindow *arg1 = (wxWindow *) 0 ;
33094 wxWindow *arg2 = (wxWindow *) 0 ;
33095 void *argp1 = 0 ;
33096 int res1 = 0 ;
33097 void *argp2 = 0 ;
33098 int res2 = 0 ;
33099 PyObject * obj0 = 0 ;
33100 PyObject * obj1 = 0 ;
33101 char * kwnames[] = {
33102 (char *) "self",(char *) "child", NULL
33103 };
33104
33105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33112 if (!SWIG_IsOK(res2)) {
33113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33114 }
33115 arg2 = reinterpret_cast< wxWindow * >(argp2);
33116 {
33117 PyThreadState* __tstate = wxPyBeginAllowThreads();
33118 (arg1)->RemoveChild(arg2);
33119 wxPyEndAllowThreads(__tstate);
33120 if (PyErr_Occurred()) SWIG_fail;
33121 }
33122 resultobj = SWIG_Py_Void();
33123 return resultobj;
33124 fail:
33125 return NULL;
33126 }
33127
33128
33129 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33130 PyObject *resultobj = 0;
33131 wxWindow *arg1 = (wxWindow *) 0 ;
33132 long arg2 ;
33133 wxWindow *result = 0 ;
33134 void *argp1 = 0 ;
33135 int res1 = 0 ;
33136 long val2 ;
33137 int ecode2 = 0 ;
33138 PyObject * obj0 = 0 ;
33139 PyObject * obj1 = 0 ;
33140 char * kwnames[] = {
33141 (char *) "self",(char *) "winid", NULL
33142 };
33143
33144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33146 if (!SWIG_IsOK(res1)) {
33147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33148 }
33149 arg1 = reinterpret_cast< wxWindow * >(argp1);
33150 ecode2 = SWIG_AsVal_long(obj1, &val2);
33151 if (!SWIG_IsOK(ecode2)) {
33152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33153 }
33154 arg2 = static_cast< long >(val2);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (wxWindow *)(arg1)->FindWindow(arg2);
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 {
33162 resultobj = wxPyMake_wxObject(result, 0);
33163 }
33164 return resultobj;
33165 fail:
33166 return NULL;
33167 }
33168
33169
33170 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33171 PyObject *resultobj = 0;
33172 wxWindow *arg1 = (wxWindow *) 0 ;
33173 wxString *arg2 = 0 ;
33174 wxWindow *result = 0 ;
33175 void *argp1 = 0 ;
33176 int res1 = 0 ;
33177 bool temp2 = false ;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char * kwnames[] = {
33181 (char *) "self",(char *) "name", NULL
33182 };
33183
33184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33186 if (!SWIG_IsOK(res1)) {
33187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33188 }
33189 arg1 = reinterpret_cast< wxWindow * >(argp1);
33190 {
33191 arg2 = wxString_in_helper(obj1);
33192 if (arg2 == NULL) SWIG_fail;
33193 temp2 = true;
33194 }
33195 {
33196 PyThreadState* __tstate = wxPyBeginAllowThreads();
33197 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33198 wxPyEndAllowThreads(__tstate);
33199 if (PyErr_Occurred()) SWIG_fail;
33200 }
33201 {
33202 resultobj = wxPyMake_wxObject(result, 0);
33203 }
33204 {
33205 if (temp2)
33206 delete arg2;
33207 }
33208 return resultobj;
33209 fail:
33210 {
33211 if (temp2)
33212 delete arg2;
33213 }
33214 return NULL;
33215 }
33216
33217
33218 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33219 PyObject *resultobj = 0;
33220 wxWindow *arg1 = (wxWindow *) 0 ;
33221 wxEvtHandler *result = 0 ;
33222 void *argp1 = 0 ;
33223 int res1 = 0 ;
33224 PyObject *swig_obj[1] ;
33225
33226 if (!args) SWIG_fail;
33227 swig_obj[0] = args;
33228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33229 if (!SWIG_IsOK(res1)) {
33230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33231 }
33232 arg1 = reinterpret_cast< wxWindow * >(argp1);
33233 {
33234 PyThreadState* __tstate = wxPyBeginAllowThreads();
33235 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 {
33240 resultobj = wxPyMake_wxObject(result, 0);
33241 }
33242 return resultobj;
33243 fail:
33244 return NULL;
33245 }
33246
33247
33248 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33249 PyObject *resultobj = 0;
33250 wxWindow *arg1 = (wxWindow *) 0 ;
33251 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33252 void *argp1 = 0 ;
33253 int res1 = 0 ;
33254 void *argp2 = 0 ;
33255 int res2 = 0 ;
33256 PyObject * obj0 = 0 ;
33257 PyObject * obj1 = 0 ;
33258 char * kwnames[] = {
33259 (char *) "self",(char *) "handler", NULL
33260 };
33261
33262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33264 if (!SWIG_IsOK(res1)) {
33265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33266 }
33267 arg1 = reinterpret_cast< wxWindow * >(argp1);
33268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33269 if (!SWIG_IsOK(res2)) {
33270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33271 }
33272 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 (arg1)->SetEventHandler(arg2);
33276 wxPyEndAllowThreads(__tstate);
33277 if (PyErr_Occurred()) SWIG_fail;
33278 }
33279 resultobj = SWIG_Py_Void();
33280 return resultobj;
33281 fail:
33282 return NULL;
33283 }
33284
33285
33286 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33287 PyObject *resultobj = 0;
33288 wxWindow *arg1 = (wxWindow *) 0 ;
33289 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33290 void *argp1 = 0 ;
33291 int res1 = 0 ;
33292 void *argp2 = 0 ;
33293 int res2 = 0 ;
33294 PyObject * obj0 = 0 ;
33295 PyObject * obj1 = 0 ;
33296 char * kwnames[] = {
33297 (char *) "self",(char *) "handler", NULL
33298 };
33299
33300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33302 if (!SWIG_IsOK(res1)) {
33303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33304 }
33305 arg1 = reinterpret_cast< wxWindow * >(argp1);
33306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33307 if (!SWIG_IsOK(res2)) {
33308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33309 }
33310 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 (arg1)->PushEventHandler(arg2);
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 resultobj = SWIG_Py_Void();
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj = 0;
33326 wxWindow *arg1 = (wxWindow *) 0 ;
33327 bool arg2 = (bool) false ;
33328 wxEvtHandler *result = 0 ;
33329 void *argp1 = 0 ;
33330 int res1 = 0 ;
33331 bool val2 ;
33332 int ecode2 = 0 ;
33333 PyObject * obj0 = 0 ;
33334 PyObject * obj1 = 0 ;
33335 char * kwnames[] = {
33336 (char *) "self",(char *) "deleteHandler", NULL
33337 };
33338
33339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33341 if (!SWIG_IsOK(res1)) {
33342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33343 }
33344 arg1 = reinterpret_cast< wxWindow * >(argp1);
33345 if (obj1) {
33346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33347 if (!SWIG_IsOK(ecode2)) {
33348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33349 }
33350 arg2 = static_cast< bool >(val2);
33351 }
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 {
33359 resultobj = wxPyMake_wxObject(result, 0);
33360 }
33361 return resultobj;
33362 fail:
33363 return NULL;
33364 }
33365
33366
33367 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33368 PyObject *resultobj = 0;
33369 wxWindow *arg1 = (wxWindow *) 0 ;
33370 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33371 bool result;
33372 void *argp1 = 0 ;
33373 int res1 = 0 ;
33374 void *argp2 = 0 ;
33375 int res2 = 0 ;
33376 PyObject * obj0 = 0 ;
33377 PyObject * obj1 = 0 ;
33378 char * kwnames[] = {
33379 (char *) "self",(char *) "handler", NULL
33380 };
33381
33382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33384 if (!SWIG_IsOK(res1)) {
33385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33386 }
33387 arg1 = reinterpret_cast< wxWindow * >(argp1);
33388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33389 if (!SWIG_IsOK(res2)) {
33390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33391 }
33392 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33393 {
33394 PyThreadState* __tstate = wxPyBeginAllowThreads();
33395 result = (bool)(arg1)->RemoveEventHandler(arg2);
33396 wxPyEndAllowThreads(__tstate);
33397 if (PyErr_Occurred()) SWIG_fail;
33398 }
33399 {
33400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33401 }
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33409 PyObject *resultobj = 0;
33410 wxWindow *arg1 = (wxWindow *) 0 ;
33411 wxValidator *arg2 = 0 ;
33412 void *argp1 = 0 ;
33413 int res1 = 0 ;
33414 void *argp2 = 0 ;
33415 int res2 = 0 ;
33416 PyObject * obj0 = 0 ;
33417 PyObject * obj1 = 0 ;
33418 char * kwnames[] = {
33419 (char *) "self",(char *) "validator", NULL
33420 };
33421
33422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33424 if (!SWIG_IsOK(res1)) {
33425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33426 }
33427 arg1 = reinterpret_cast< wxWindow * >(argp1);
33428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33429 if (!SWIG_IsOK(res2)) {
33430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33431 }
33432 if (!argp2) {
33433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33434 }
33435 arg2 = reinterpret_cast< wxValidator * >(argp2);
33436 {
33437 PyThreadState* __tstate = wxPyBeginAllowThreads();
33438 (arg1)->SetValidator((wxValidator const &)*arg2);
33439 wxPyEndAllowThreads(__tstate);
33440 if (PyErr_Occurred()) SWIG_fail;
33441 }
33442 resultobj = SWIG_Py_Void();
33443 return resultobj;
33444 fail:
33445 return NULL;
33446 }
33447
33448
33449 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33450 PyObject *resultobj = 0;
33451 wxWindow *arg1 = (wxWindow *) 0 ;
33452 wxValidator *result = 0 ;
33453 void *argp1 = 0 ;
33454 int res1 = 0 ;
33455 PyObject *swig_obj[1] ;
33456
33457 if (!args) SWIG_fail;
33458 swig_obj[0] = args;
33459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33460 if (!SWIG_IsOK(res1)) {
33461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33462 }
33463 arg1 = reinterpret_cast< wxWindow * >(argp1);
33464 {
33465 PyThreadState* __tstate = wxPyBeginAllowThreads();
33466 result = (wxValidator *)(arg1)->GetValidator();
33467 wxPyEndAllowThreads(__tstate);
33468 if (PyErr_Occurred()) SWIG_fail;
33469 }
33470 {
33471 resultobj = wxPyMake_wxObject(result, (bool)0);
33472 }
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33480 PyObject *resultobj = 0;
33481 wxWindow *arg1 = (wxWindow *) 0 ;
33482 bool result;
33483 void *argp1 = 0 ;
33484 int res1 = 0 ;
33485 PyObject *swig_obj[1] ;
33486
33487 if (!args) SWIG_fail;
33488 swig_obj[0] = args;
33489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33490 if (!SWIG_IsOK(res1)) {
33491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33492 }
33493 arg1 = reinterpret_cast< wxWindow * >(argp1);
33494 {
33495 PyThreadState* __tstate = wxPyBeginAllowThreads();
33496 result = (bool)(arg1)->Validate();
33497 wxPyEndAllowThreads(__tstate);
33498 if (PyErr_Occurred()) SWIG_fail;
33499 }
33500 {
33501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33502 }
33503 return resultobj;
33504 fail:
33505 return NULL;
33506 }
33507
33508
33509 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33510 PyObject *resultobj = 0;
33511 wxWindow *arg1 = (wxWindow *) 0 ;
33512 bool result;
33513 void *argp1 = 0 ;
33514 int res1 = 0 ;
33515 PyObject *swig_obj[1] ;
33516
33517 if (!args) SWIG_fail;
33518 swig_obj[0] = args;
33519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33520 if (!SWIG_IsOK(res1)) {
33521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33522 }
33523 arg1 = reinterpret_cast< wxWindow * >(argp1);
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (bool)(arg1)->TransferDataToWindow();
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 {
33531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33532 }
33533 return resultobj;
33534 fail:
33535 return NULL;
33536 }
33537
33538
33539 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33540 PyObject *resultobj = 0;
33541 wxWindow *arg1 = (wxWindow *) 0 ;
33542 bool result;
33543 void *argp1 = 0 ;
33544 int res1 = 0 ;
33545 PyObject *swig_obj[1] ;
33546
33547 if (!args) SWIG_fail;
33548 swig_obj[0] = args;
33549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33550 if (!SWIG_IsOK(res1)) {
33551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33552 }
33553 arg1 = reinterpret_cast< wxWindow * >(argp1);
33554 {
33555 PyThreadState* __tstate = wxPyBeginAllowThreads();
33556 result = (bool)(arg1)->TransferDataFromWindow();
33557 wxPyEndAllowThreads(__tstate);
33558 if (PyErr_Occurred()) SWIG_fail;
33559 }
33560 {
33561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33562 }
33563 return resultobj;
33564 fail:
33565 return NULL;
33566 }
33567
33568
33569 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33570 PyObject *resultobj = 0;
33571 wxWindow *arg1 = (wxWindow *) 0 ;
33572 void *argp1 = 0 ;
33573 int res1 = 0 ;
33574 PyObject *swig_obj[1] ;
33575
33576 if (!args) SWIG_fail;
33577 swig_obj[0] = args;
33578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33579 if (!SWIG_IsOK(res1)) {
33580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33581 }
33582 arg1 = reinterpret_cast< wxWindow * >(argp1);
33583 {
33584 PyThreadState* __tstate = wxPyBeginAllowThreads();
33585 (arg1)->InitDialog();
33586 wxPyEndAllowThreads(__tstate);
33587 if (PyErr_Occurred()) SWIG_fail;
33588 }
33589 resultobj = SWIG_Py_Void();
33590 return resultobj;
33591 fail:
33592 return NULL;
33593 }
33594
33595
33596 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33597 PyObject *resultobj = 0;
33598 wxWindow *arg1 = (wxWindow *) 0 ;
33599 wxAcceleratorTable *arg2 = 0 ;
33600 void *argp1 = 0 ;
33601 int res1 = 0 ;
33602 void *argp2 = 0 ;
33603 int res2 = 0 ;
33604 PyObject * obj0 = 0 ;
33605 PyObject * obj1 = 0 ;
33606 char * kwnames[] = {
33607 (char *) "self",(char *) "accel", NULL
33608 };
33609
33610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33612 if (!SWIG_IsOK(res1)) {
33613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33614 }
33615 arg1 = reinterpret_cast< wxWindow * >(argp1);
33616 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33617 if (!SWIG_IsOK(res2)) {
33618 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33619 }
33620 if (!argp2) {
33621 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33622 }
33623 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33624 {
33625 PyThreadState* __tstate = wxPyBeginAllowThreads();
33626 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33627 wxPyEndAllowThreads(__tstate);
33628 if (PyErr_Occurred()) SWIG_fail;
33629 }
33630 resultobj = SWIG_Py_Void();
33631 return resultobj;
33632 fail:
33633 return NULL;
33634 }
33635
33636
33637 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33638 PyObject *resultobj = 0;
33639 wxWindow *arg1 = (wxWindow *) 0 ;
33640 wxAcceleratorTable *result = 0 ;
33641 void *argp1 = 0 ;
33642 int res1 = 0 ;
33643 PyObject *swig_obj[1] ;
33644
33645 if (!args) SWIG_fail;
33646 swig_obj[0] = args;
33647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33648 if (!SWIG_IsOK(res1)) {
33649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33650 }
33651 arg1 = reinterpret_cast< wxWindow * >(argp1);
33652 {
33653 PyThreadState* __tstate = wxPyBeginAllowThreads();
33654 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33655 wxPyEndAllowThreads(__tstate);
33656 if (PyErr_Occurred()) SWIG_fail;
33657 }
33658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33659 return resultobj;
33660 fail:
33661 return NULL;
33662 }
33663
33664
33665 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33666 PyObject *resultobj = 0;
33667 wxWindow *arg1 = (wxWindow *) 0 ;
33668 int arg2 ;
33669 int arg3 ;
33670 int arg4 ;
33671 bool result;
33672 void *argp1 = 0 ;
33673 int res1 = 0 ;
33674 int val2 ;
33675 int ecode2 = 0 ;
33676 int val3 ;
33677 int ecode3 = 0 ;
33678 int val4 ;
33679 int ecode4 = 0 ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 PyObject * obj2 = 0 ;
33683 PyObject * obj3 = 0 ;
33684 char * kwnames[] = {
33685 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33686 };
33687
33688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33690 if (!SWIG_IsOK(res1)) {
33691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33692 }
33693 arg1 = reinterpret_cast< wxWindow * >(argp1);
33694 ecode2 = SWIG_AsVal_int(obj1, &val2);
33695 if (!SWIG_IsOK(ecode2)) {
33696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33697 }
33698 arg2 = static_cast< int >(val2);
33699 ecode3 = SWIG_AsVal_int(obj2, &val3);
33700 if (!SWIG_IsOK(ecode3)) {
33701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33702 }
33703 arg3 = static_cast< int >(val3);
33704 ecode4 = SWIG_AsVal_int(obj3, &val4);
33705 if (!SWIG_IsOK(ecode4)) {
33706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33707 }
33708 arg4 = static_cast< int >(val4);
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 {
33716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33717 }
33718 return resultobj;
33719 fail:
33720 return NULL;
33721 }
33722
33723
33724 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33725 PyObject *resultobj = 0;
33726 wxWindow *arg1 = (wxWindow *) 0 ;
33727 int arg2 ;
33728 bool result;
33729 void *argp1 = 0 ;
33730 int res1 = 0 ;
33731 int val2 ;
33732 int ecode2 = 0 ;
33733 PyObject * obj0 = 0 ;
33734 PyObject * obj1 = 0 ;
33735 char * kwnames[] = {
33736 (char *) "self",(char *) "hotkeyId", NULL
33737 };
33738
33739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33741 if (!SWIG_IsOK(res1)) {
33742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33743 }
33744 arg1 = reinterpret_cast< wxWindow * >(argp1);
33745 ecode2 = SWIG_AsVal_int(obj1, &val2);
33746 if (!SWIG_IsOK(ecode2)) {
33747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33748 }
33749 arg2 = static_cast< int >(val2);
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 {
33757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33758 }
33759 return resultobj;
33760 fail:
33761 return NULL;
33762 }
33763
33764
33765 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33766 PyObject *resultobj = 0;
33767 wxWindow *arg1 = (wxWindow *) 0 ;
33768 wxPoint *arg2 = 0 ;
33769 wxPoint result;
33770 void *argp1 = 0 ;
33771 int res1 = 0 ;
33772 wxPoint temp2 ;
33773 PyObject * obj0 = 0 ;
33774 PyObject * obj1 = 0 ;
33775 char * kwnames[] = {
33776 (char *) "self",(char *) "pt", NULL
33777 };
33778
33779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33781 if (!SWIG_IsOK(res1)) {
33782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33783 }
33784 arg1 = reinterpret_cast< wxWindow * >(argp1);
33785 {
33786 arg2 = &temp2;
33787 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33788 }
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33792 wxPyEndAllowThreads(__tstate);
33793 if (PyErr_Occurred()) SWIG_fail;
33794 }
33795 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33796 return resultobj;
33797 fail:
33798 return NULL;
33799 }
33800
33801
33802 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33803 PyObject *resultobj = 0;
33804 wxWindow *arg1 = (wxWindow *) 0 ;
33805 wxSize *arg2 = 0 ;
33806 wxSize result;
33807 void *argp1 = 0 ;
33808 int res1 = 0 ;
33809 wxSize temp2 ;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "sz", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33820 }
33821 arg1 = reinterpret_cast< wxWindow * >(argp1);
33822 {
33823 arg2 = &temp2;
33824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33825 }
33826 {
33827 PyThreadState* __tstate = wxPyBeginAllowThreads();
33828 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33829 wxPyEndAllowThreads(__tstate);
33830 if (PyErr_Occurred()) SWIG_fail;
33831 }
33832 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33833 return resultobj;
33834 fail:
33835 return NULL;
33836 }
33837
33838
33839 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33840 PyObject *resultobj = 0;
33841 wxWindow *arg1 = (wxWindow *) 0 ;
33842 wxPoint *arg2 = 0 ;
33843 wxPoint result;
33844 void *argp1 = 0 ;
33845 int res1 = 0 ;
33846 wxPoint temp2 ;
33847 PyObject * obj0 = 0 ;
33848 PyObject * obj1 = 0 ;
33849 char * kwnames[] = {
33850 (char *) "self",(char *) "pt", NULL
33851 };
33852
33853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33855 if (!SWIG_IsOK(res1)) {
33856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33857 }
33858 arg1 = reinterpret_cast< wxWindow * >(argp1);
33859 {
33860 arg2 = &temp2;
33861 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33862 }
33863 {
33864 PyThreadState* __tstate = wxPyBeginAllowThreads();
33865 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33866 wxPyEndAllowThreads(__tstate);
33867 if (PyErr_Occurred()) SWIG_fail;
33868 }
33869 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33870 return resultobj;
33871 fail:
33872 return NULL;
33873 }
33874
33875
33876 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33877 PyObject *resultobj = 0;
33878 wxWindow *arg1 = (wxWindow *) 0 ;
33879 wxSize *arg2 = 0 ;
33880 wxSize result;
33881 void *argp1 = 0 ;
33882 int res1 = 0 ;
33883 wxSize temp2 ;
33884 PyObject * obj0 = 0 ;
33885 PyObject * obj1 = 0 ;
33886 char * kwnames[] = {
33887 (char *) "self",(char *) "sz", NULL
33888 };
33889
33890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33892 if (!SWIG_IsOK(res1)) {
33893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33894 }
33895 arg1 = reinterpret_cast< wxWindow * >(argp1);
33896 {
33897 arg2 = &temp2;
33898 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33899 }
33900 {
33901 PyThreadState* __tstate = wxPyBeginAllowThreads();
33902 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33903 wxPyEndAllowThreads(__tstate);
33904 if (PyErr_Occurred()) SWIG_fail;
33905 }
33906 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 wxPoint *arg2 = 0 ;
33917 wxPoint result;
33918 void *argp1 = 0 ;
33919 int res1 = 0 ;
33920 wxPoint temp2 ;
33921 PyObject * obj0 = 0 ;
33922 PyObject * obj1 = 0 ;
33923 char * kwnames[] = {
33924 (char *) "self",(char *) "pt", NULL
33925 };
33926
33927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33929 if (!SWIG_IsOK(res1)) {
33930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33931 }
33932 arg1 = reinterpret_cast< wxWindow * >(argp1);
33933 {
33934 arg2 = &temp2;
33935 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33936 }
33937 {
33938 PyThreadState* __tstate = wxPyBeginAllowThreads();
33939 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33940 wxPyEndAllowThreads(__tstate);
33941 if (PyErr_Occurred()) SWIG_fail;
33942 }
33943 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33944 return resultobj;
33945 fail:
33946 return NULL;
33947 }
33948
33949
33950 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33951 PyObject *resultobj = 0;
33952 wxWindow *arg1 = (wxWindow *) 0 ;
33953 wxSize *arg2 = 0 ;
33954 wxSize result;
33955 void *argp1 = 0 ;
33956 int res1 = 0 ;
33957 wxSize temp2 ;
33958 PyObject * obj0 = 0 ;
33959 PyObject * obj1 = 0 ;
33960 char * kwnames[] = {
33961 (char *) "self",(char *) "sz", NULL
33962 };
33963
33964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33966 if (!SWIG_IsOK(res1)) {
33967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33968 }
33969 arg1 = reinterpret_cast< wxWindow * >(argp1);
33970 {
33971 arg2 = &temp2;
33972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33973 }
33974 {
33975 PyThreadState* __tstate = wxPyBeginAllowThreads();
33976 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33977 wxPyEndAllowThreads(__tstate);
33978 if (PyErr_Occurred()) SWIG_fail;
33979 }
33980 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33981 return resultobj;
33982 fail:
33983 return NULL;
33984 }
33985
33986
33987 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33988 PyObject *resultobj = 0;
33989 wxWindow *arg1 = (wxWindow *) 0 ;
33990 int arg2 ;
33991 int arg3 ;
33992 void *argp1 = 0 ;
33993 int res1 = 0 ;
33994 int val2 ;
33995 int ecode2 = 0 ;
33996 int val3 ;
33997 int ecode3 = 0 ;
33998 PyObject * obj0 = 0 ;
33999 PyObject * obj1 = 0 ;
34000 PyObject * obj2 = 0 ;
34001 char * kwnames[] = {
34002 (char *) "self",(char *) "x",(char *) "y", NULL
34003 };
34004
34005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34007 if (!SWIG_IsOK(res1)) {
34008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34009 }
34010 arg1 = reinterpret_cast< wxWindow * >(argp1);
34011 ecode2 = SWIG_AsVal_int(obj1, &val2);
34012 if (!SWIG_IsOK(ecode2)) {
34013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34014 }
34015 arg2 = static_cast< int >(val2);
34016 ecode3 = SWIG_AsVal_int(obj2, &val3);
34017 if (!SWIG_IsOK(ecode3)) {
34018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34019 }
34020 arg3 = static_cast< int >(val3);
34021 {
34022 PyThreadState* __tstate = wxPyBeginAllowThreads();
34023 (arg1)->WarpPointer(arg2,arg3);
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 resultobj = SWIG_Py_Void();
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34035 PyObject *resultobj = 0;
34036 wxWindow *arg1 = (wxWindow *) 0 ;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 PyObject *swig_obj[1] ;
34040
34041 if (!args) SWIG_fail;
34042 swig_obj[0] = args;
34043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34044 if (!SWIG_IsOK(res1)) {
34045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34046 }
34047 arg1 = reinterpret_cast< wxWindow * >(argp1);
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 (arg1)->CaptureMouse();
34051 wxPyEndAllowThreads(__tstate);
34052 if (PyErr_Occurred()) SWIG_fail;
34053 }
34054 resultobj = SWIG_Py_Void();
34055 return resultobj;
34056 fail:
34057 return NULL;
34058 }
34059
34060
34061 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34062 PyObject *resultobj = 0;
34063 wxWindow *arg1 = (wxWindow *) 0 ;
34064 void *argp1 = 0 ;
34065 int res1 = 0 ;
34066 PyObject *swig_obj[1] ;
34067
34068 if (!args) SWIG_fail;
34069 swig_obj[0] = args;
34070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34071 if (!SWIG_IsOK(res1)) {
34072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34073 }
34074 arg1 = reinterpret_cast< wxWindow * >(argp1);
34075 {
34076 PyThreadState* __tstate = wxPyBeginAllowThreads();
34077 (arg1)->ReleaseMouse();
34078 wxPyEndAllowThreads(__tstate);
34079 if (PyErr_Occurred()) SWIG_fail;
34080 }
34081 resultobj = SWIG_Py_Void();
34082 return resultobj;
34083 fail:
34084 return NULL;
34085 }
34086
34087
34088 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34089 PyObject *resultobj = 0;
34090 wxWindow *result = 0 ;
34091
34092 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34093 {
34094 if (!wxPyCheckForApp()) SWIG_fail;
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 result = (wxWindow *)wxWindow::GetCapture();
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 {
34101 resultobj = wxPyMake_wxObject(result, 0);
34102 }
34103 return resultobj;
34104 fail:
34105 return NULL;
34106 }
34107
34108
34109 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34110 PyObject *resultobj = 0;
34111 wxWindow *arg1 = (wxWindow *) 0 ;
34112 bool result;
34113 void *argp1 = 0 ;
34114 int res1 = 0 ;
34115 PyObject *swig_obj[1] ;
34116
34117 if (!args) SWIG_fail;
34118 swig_obj[0] = args;
34119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34120 if (!SWIG_IsOK(res1)) {
34121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34122 }
34123 arg1 = reinterpret_cast< wxWindow * >(argp1);
34124 {
34125 PyThreadState* __tstate = wxPyBeginAllowThreads();
34126 result = (bool)((wxWindow const *)arg1)->HasCapture();
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 {
34131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34132 }
34133 return resultobj;
34134 fail:
34135 return NULL;
34136 }
34137
34138
34139 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34140 PyObject *resultobj = 0;
34141 wxWindow *arg1 = (wxWindow *) 0 ;
34142 bool arg2 = (bool) true ;
34143 wxRect *arg3 = (wxRect *) NULL ;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 bool val2 ;
34147 int ecode2 = 0 ;
34148 void *argp3 = 0 ;
34149 int res3 = 0 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 PyObject * obj2 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34161 }
34162 arg1 = reinterpret_cast< wxWindow * >(argp1);
34163 if (obj1) {
34164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34165 if (!SWIG_IsOK(ecode2)) {
34166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34167 }
34168 arg2 = static_cast< bool >(val2);
34169 }
34170 if (obj2) {
34171 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34172 if (!SWIG_IsOK(res3)) {
34173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34174 }
34175 arg3 = reinterpret_cast< wxRect * >(argp3);
34176 }
34177 {
34178 PyThreadState* __tstate = wxPyBeginAllowThreads();
34179 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34180 wxPyEndAllowThreads(__tstate);
34181 if (PyErr_Occurred()) SWIG_fail;
34182 }
34183 resultobj = SWIG_Py_Void();
34184 return resultobj;
34185 fail:
34186 return NULL;
34187 }
34188
34189
34190 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34191 PyObject *resultobj = 0;
34192 wxWindow *arg1 = (wxWindow *) 0 ;
34193 wxRect *arg2 = 0 ;
34194 bool arg3 = (bool) true ;
34195 void *argp1 = 0 ;
34196 int res1 = 0 ;
34197 wxRect temp2 ;
34198 bool val3 ;
34199 int ecode3 = 0 ;
34200 PyObject * obj0 = 0 ;
34201 PyObject * obj1 = 0 ;
34202 PyObject * obj2 = 0 ;
34203 char * kwnames[] = {
34204 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34205 };
34206
34207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34211 }
34212 arg1 = reinterpret_cast< wxWindow * >(argp1);
34213 {
34214 arg2 = &temp2;
34215 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34216 }
34217 if (obj2) {
34218 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34219 if (!SWIG_IsOK(ecode3)) {
34220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34221 }
34222 arg3 = static_cast< bool >(val3);
34223 }
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 resultobj = SWIG_Py_Void();
34231 return resultobj;
34232 fail:
34233 return NULL;
34234 }
34235
34236
34237 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34238 PyObject *resultobj = 0;
34239 wxWindow *arg1 = (wxWindow *) 0 ;
34240 void *argp1 = 0 ;
34241 int res1 = 0 ;
34242 PyObject *swig_obj[1] ;
34243
34244 if (!args) SWIG_fail;
34245 swig_obj[0] = args;
34246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34247 if (!SWIG_IsOK(res1)) {
34248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34249 }
34250 arg1 = reinterpret_cast< wxWindow * >(argp1);
34251 {
34252 PyThreadState* __tstate = wxPyBeginAllowThreads();
34253 (arg1)->Update();
34254 wxPyEndAllowThreads(__tstate);
34255 if (PyErr_Occurred()) SWIG_fail;
34256 }
34257 resultobj = SWIG_Py_Void();
34258 return resultobj;
34259 fail:
34260 return NULL;
34261 }
34262
34263
34264 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34265 PyObject *resultobj = 0;
34266 wxWindow *arg1 = (wxWindow *) 0 ;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 PyObject *swig_obj[1] ;
34270
34271 if (!args) SWIG_fail;
34272 swig_obj[0] = args;
34273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34274 if (!SWIG_IsOK(res1)) {
34275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34276 }
34277 arg1 = reinterpret_cast< wxWindow * >(argp1);
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 (arg1)->ClearBackground();
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 resultobj = SWIG_Py_Void();
34285 return resultobj;
34286 fail:
34287 return NULL;
34288 }
34289
34290
34291 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34292 PyObject *resultobj = 0;
34293 wxWindow *arg1 = (wxWindow *) 0 ;
34294 void *argp1 = 0 ;
34295 int res1 = 0 ;
34296 PyObject *swig_obj[1] ;
34297
34298 if (!args) SWIG_fail;
34299 swig_obj[0] = args;
34300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34301 if (!SWIG_IsOK(res1)) {
34302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34303 }
34304 arg1 = reinterpret_cast< wxWindow * >(argp1);
34305 {
34306 PyThreadState* __tstate = wxPyBeginAllowThreads();
34307 (arg1)->Freeze();
34308 wxPyEndAllowThreads(__tstate);
34309 if (PyErr_Occurred()) SWIG_fail;
34310 }
34311 resultobj = SWIG_Py_Void();
34312 return resultobj;
34313 fail:
34314 return NULL;
34315 }
34316
34317
34318 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34319 PyObject *resultobj = 0;
34320 wxWindow *arg1 = (wxWindow *) 0 ;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 PyObject *swig_obj[1] ;
34324
34325 if (!args) SWIG_fail;
34326 swig_obj[0] = args;
34327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 (arg1)->Thaw();
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 resultobj = SWIG_Py_Void();
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj = 0;
34347 wxWindow *arg1 = (wxWindow *) 0 ;
34348 wxDC *arg2 = 0 ;
34349 void *argp1 = 0 ;
34350 int res1 = 0 ;
34351 void *argp2 = 0 ;
34352 int res2 = 0 ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 char * kwnames[] = {
34356 (char *) "self",(char *) "dc", NULL
34357 };
34358
34359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34363 }
34364 arg1 = reinterpret_cast< wxWindow * >(argp1);
34365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34366 if (!SWIG_IsOK(res2)) {
34367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34368 }
34369 if (!argp2) {
34370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34371 }
34372 arg2 = reinterpret_cast< wxDC * >(argp2);
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 (arg1)->PrepareDC(*arg2);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 resultobj = SWIG_Py_Void();
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxRegion *result = 0 ;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 {
34404 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34405 result = (wxRegion *) &_result_ref;
34406 }
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34418 PyObject *resultobj = 0;
34419 wxWindow *arg1 = (wxWindow *) 0 ;
34420 wxRect result;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 PyObject *swig_obj[1] ;
34424
34425 if (!args) SWIG_fail;
34426 swig_obj[0] = args;
34427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34428 if (!SWIG_IsOK(res1)) {
34429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34430 }
34431 arg1 = reinterpret_cast< wxWindow * >(argp1);
34432 {
34433 PyThreadState* __tstate = wxPyBeginAllowThreads();
34434 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34435 wxPyEndAllowThreads(__tstate);
34436 if (PyErr_Occurred()) SWIG_fail;
34437 }
34438 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34439 return resultobj;
34440 fail:
34441 return NULL;
34442 }
34443
34444
34445 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34446 PyObject *resultobj = 0;
34447 wxWindow *arg1 = (wxWindow *) 0 ;
34448 int arg2 ;
34449 int arg3 ;
34450 int arg4 = (int) 1 ;
34451 int arg5 = (int) 1 ;
34452 bool result;
34453 void *argp1 = 0 ;
34454 int res1 = 0 ;
34455 int val2 ;
34456 int ecode2 = 0 ;
34457 int val3 ;
34458 int ecode3 = 0 ;
34459 int val4 ;
34460 int ecode4 = 0 ;
34461 int val5 ;
34462 int ecode5 = 0 ;
34463 PyObject * obj0 = 0 ;
34464 PyObject * obj1 = 0 ;
34465 PyObject * obj2 = 0 ;
34466 PyObject * obj3 = 0 ;
34467 PyObject * obj4 = 0 ;
34468 char * kwnames[] = {
34469 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34470 };
34471
34472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34476 }
34477 arg1 = reinterpret_cast< wxWindow * >(argp1);
34478 ecode2 = SWIG_AsVal_int(obj1, &val2);
34479 if (!SWIG_IsOK(ecode2)) {
34480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34481 }
34482 arg2 = static_cast< int >(val2);
34483 ecode3 = SWIG_AsVal_int(obj2, &val3);
34484 if (!SWIG_IsOK(ecode3)) {
34485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34486 }
34487 arg3 = static_cast< int >(val3);
34488 if (obj3) {
34489 ecode4 = SWIG_AsVal_int(obj3, &val4);
34490 if (!SWIG_IsOK(ecode4)) {
34491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34492 }
34493 arg4 = static_cast< int >(val4);
34494 }
34495 if (obj4) {
34496 ecode5 = SWIG_AsVal_int(obj4, &val5);
34497 if (!SWIG_IsOK(ecode5)) {
34498 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34499 }
34500 arg5 = static_cast< int >(val5);
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 {
34509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34510 }
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 wxPoint *arg2 = 0 ;
34521 bool result;
34522 void *argp1 = 0 ;
34523 int res1 = 0 ;
34524 wxPoint temp2 ;
34525 PyObject * obj0 = 0 ;
34526 PyObject * obj1 = 0 ;
34527 char * kwnames[] = {
34528 (char *) "self",(char *) "pt", NULL
34529 };
34530
34531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34533 if (!SWIG_IsOK(res1)) {
34534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34535 }
34536 arg1 = reinterpret_cast< wxWindow * >(argp1);
34537 {
34538 arg2 = &temp2;
34539 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34540 }
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 {
34548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34549 }
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34557 PyObject *resultobj = 0;
34558 wxWindow *arg1 = (wxWindow *) 0 ;
34559 wxRect *arg2 = 0 ;
34560 bool result;
34561 void *argp1 = 0 ;
34562 int res1 = 0 ;
34563 wxRect temp2 ;
34564 PyObject * obj0 = 0 ;
34565 PyObject * obj1 = 0 ;
34566 char * kwnames[] = {
34567 (char *) "self",(char *) "rect", NULL
34568 };
34569
34570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34572 if (!SWIG_IsOK(res1)) {
34573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34574 }
34575 arg1 = reinterpret_cast< wxWindow * >(argp1);
34576 {
34577 arg2 = &temp2;
34578 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34579 }
34580 {
34581 PyThreadState* __tstate = wxPyBeginAllowThreads();
34582 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34583 wxPyEndAllowThreads(__tstate);
34584 if (PyErr_Occurred()) SWIG_fail;
34585 }
34586 {
34587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34588 }
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 SwigValueWrapper<wxVisualAttributes > result;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 PyObject *swig_obj[1] ;
34602
34603 if (!args) SWIG_fail;
34604 swig_obj[0] = args;
34605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34606 if (!SWIG_IsOK(res1)) {
34607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34608 }
34609 arg1 = reinterpret_cast< wxWindow * >(argp1);
34610 {
34611 PyThreadState* __tstate = wxPyBeginAllowThreads();
34612 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34613 wxPyEndAllowThreads(__tstate);
34614 if (PyErr_Occurred()) SWIG_fail;
34615 }
34616 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34617 return resultobj;
34618 fail:
34619 return NULL;
34620 }
34621
34622
34623 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34624 PyObject *resultobj = 0;
34625 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34626 SwigValueWrapper<wxVisualAttributes > result;
34627 int val1 ;
34628 int ecode1 = 0 ;
34629 PyObject * obj0 = 0 ;
34630 char * kwnames[] = {
34631 (char *) "variant", NULL
34632 };
34633
34634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34635 if (obj0) {
34636 ecode1 = SWIG_AsVal_int(obj0, &val1);
34637 if (!SWIG_IsOK(ecode1)) {
34638 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34639 }
34640 arg1 = static_cast< wxWindowVariant >(val1);
34641 }
34642 {
34643 if (!wxPyCheckForApp()) SWIG_fail;
34644 PyThreadState* __tstate = wxPyBeginAllowThreads();
34645 result = wxWindow::GetClassDefaultAttributes(arg1);
34646 wxPyEndAllowThreads(__tstate);
34647 if (PyErr_Occurred()) SWIG_fail;
34648 }
34649 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34650 return resultobj;
34651 fail:
34652 return NULL;
34653 }
34654
34655
34656 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34657 PyObject *resultobj = 0;
34658 wxWindow *arg1 = (wxWindow *) 0 ;
34659 wxColour *arg2 = 0 ;
34660 bool result;
34661 void *argp1 = 0 ;
34662 int res1 = 0 ;
34663 wxColour temp2 ;
34664 PyObject * obj0 = 0 ;
34665 PyObject * obj1 = 0 ;
34666 char * kwnames[] = {
34667 (char *) "self",(char *) "colour", NULL
34668 };
34669
34670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34672 if (!SWIG_IsOK(res1)) {
34673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34674 }
34675 arg1 = reinterpret_cast< wxWindow * >(argp1);
34676 {
34677 arg2 = &temp2;
34678 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34679 }
34680 {
34681 PyThreadState* __tstate = wxPyBeginAllowThreads();
34682 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 {
34687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34688 }
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxWindow *arg1 = (wxWindow *) 0 ;
34698 wxColour *arg2 = 0 ;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 wxColour temp2 ;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char * kwnames[] = {
34705 (char *) "self",(char *) "colour", NULL
34706 };
34707
34708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34710 if (!SWIG_IsOK(res1)) {
34711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34712 }
34713 arg1 = reinterpret_cast< wxWindow * >(argp1);
34714 {
34715 arg2 = &temp2;
34716 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34717 }
34718 {
34719 PyThreadState* __tstate = wxPyBeginAllowThreads();
34720 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34721 wxPyEndAllowThreads(__tstate);
34722 if (PyErr_Occurred()) SWIG_fail;
34723 }
34724 resultobj = SWIG_Py_Void();
34725 return resultobj;
34726 fail:
34727 return NULL;
34728 }
34729
34730
34731 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34732 PyObject *resultobj = 0;
34733 wxWindow *arg1 = (wxWindow *) 0 ;
34734 wxColour *arg2 = 0 ;
34735 bool result;
34736 void *argp1 = 0 ;
34737 int res1 = 0 ;
34738 wxColour temp2 ;
34739 PyObject * obj0 = 0 ;
34740 PyObject * obj1 = 0 ;
34741 char * kwnames[] = {
34742 (char *) "self",(char *) "colour", NULL
34743 };
34744
34745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34747 if (!SWIG_IsOK(res1)) {
34748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34749 }
34750 arg1 = reinterpret_cast< wxWindow * >(argp1);
34751 {
34752 arg2 = &temp2;
34753 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34754 }
34755 {
34756 PyThreadState* __tstate = wxPyBeginAllowThreads();
34757 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34758 wxPyEndAllowThreads(__tstate);
34759 if (PyErr_Occurred()) SWIG_fail;
34760 }
34761 {
34762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34763 }
34764 return resultobj;
34765 fail:
34766 return NULL;
34767 }
34768
34769
34770 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34771 PyObject *resultobj = 0;
34772 wxWindow *arg1 = (wxWindow *) 0 ;
34773 wxColour *arg2 = 0 ;
34774 void *argp1 = 0 ;
34775 int res1 = 0 ;
34776 wxColour temp2 ;
34777 PyObject * obj0 = 0 ;
34778 PyObject * obj1 = 0 ;
34779 char * kwnames[] = {
34780 (char *) "self",(char *) "colour", NULL
34781 };
34782
34783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34785 if (!SWIG_IsOK(res1)) {
34786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34787 }
34788 arg1 = reinterpret_cast< wxWindow * >(argp1);
34789 {
34790 arg2 = &temp2;
34791 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34792 }
34793 {
34794 PyThreadState* __tstate = wxPyBeginAllowThreads();
34795 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34796 wxPyEndAllowThreads(__tstate);
34797 if (PyErr_Occurred()) SWIG_fail;
34798 }
34799 resultobj = SWIG_Py_Void();
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34807 PyObject *resultobj = 0;
34808 wxWindow *arg1 = (wxWindow *) 0 ;
34809 wxColour result;
34810 void *argp1 = 0 ;
34811 int res1 = 0 ;
34812 PyObject *swig_obj[1] ;
34813
34814 if (!args) SWIG_fail;
34815 swig_obj[0] = args;
34816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34819 }
34820 arg1 = reinterpret_cast< wxWindow * >(argp1);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34824 wxPyEndAllowThreads(__tstate);
34825 if (PyErr_Occurred()) SWIG_fail;
34826 }
34827 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34828 return resultobj;
34829 fail:
34830 return NULL;
34831 }
34832
34833
34834 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34835 PyObject *resultobj = 0;
34836 wxWindow *arg1 = (wxWindow *) 0 ;
34837 wxColour result;
34838 void *argp1 = 0 ;
34839 int res1 = 0 ;
34840 PyObject *swig_obj[1] ;
34841
34842 if (!args) SWIG_fail;
34843 swig_obj[0] = args;
34844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34845 if (!SWIG_IsOK(res1)) {
34846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34847 }
34848 arg1 = reinterpret_cast< wxWindow * >(argp1);
34849 {
34850 PyThreadState* __tstate = wxPyBeginAllowThreads();
34851 result = ((wxWindow const *)arg1)->GetForegroundColour();
34852 wxPyEndAllowThreads(__tstate);
34853 if (PyErr_Occurred()) SWIG_fail;
34854 }
34855 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34856 return resultobj;
34857 fail:
34858 return NULL;
34859 }
34860
34861
34862 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34863 PyObject *resultobj = 0;
34864 wxWindow *arg1 = (wxWindow *) 0 ;
34865 bool result;
34866 void *argp1 = 0 ;
34867 int res1 = 0 ;
34868 PyObject *swig_obj[1] ;
34869
34870 if (!args) SWIG_fail;
34871 swig_obj[0] = args;
34872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34873 if (!SWIG_IsOK(res1)) {
34874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34875 }
34876 arg1 = reinterpret_cast< wxWindow * >(argp1);
34877 {
34878 PyThreadState* __tstate = wxPyBeginAllowThreads();
34879 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34880 wxPyEndAllowThreads(__tstate);
34881 if (PyErr_Occurred()) SWIG_fail;
34882 }
34883 {
34884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34885 }
34886 return resultobj;
34887 fail:
34888 return NULL;
34889 }
34890
34891
34892 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34893 PyObject *resultobj = 0;
34894 wxWindow *arg1 = (wxWindow *) 0 ;
34895 bool result;
34896 void *argp1 = 0 ;
34897 int res1 = 0 ;
34898 PyObject *swig_obj[1] ;
34899
34900 if (!args) SWIG_fail;
34901 swig_obj[0] = args;
34902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34903 if (!SWIG_IsOK(res1)) {
34904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34905 }
34906 arg1 = reinterpret_cast< wxWindow * >(argp1);
34907 {
34908 PyThreadState* __tstate = wxPyBeginAllowThreads();
34909 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34910 wxPyEndAllowThreads(__tstate);
34911 if (PyErr_Occurred()) SWIG_fail;
34912 }
34913 {
34914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34915 }
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxWindow *arg1 = (wxWindow *) 0 ;
34925 wxBackgroundStyle arg2 ;
34926 bool result;
34927 void *argp1 = 0 ;
34928 int res1 = 0 ;
34929 int val2 ;
34930 int ecode2 = 0 ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char * kwnames[] = {
34934 (char *) "self",(char *) "style", NULL
34935 };
34936
34937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 ecode2 = SWIG_AsVal_int(obj1, &val2);
34944 if (!SWIG_IsOK(ecode2)) {
34945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34946 }
34947 arg2 = static_cast< wxBackgroundStyle >(val2);
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34951 wxPyEndAllowThreads(__tstate);
34952 if (PyErr_Occurred()) SWIG_fail;
34953 }
34954 {
34955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34956 }
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34964 PyObject *resultobj = 0;
34965 wxWindow *arg1 = (wxWindow *) 0 ;
34966 wxBackgroundStyle result;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 PyObject *swig_obj[1] ;
34970
34971 if (!args) SWIG_fail;
34972 swig_obj[0] = args;
34973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34974 if (!SWIG_IsOK(res1)) {
34975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34976 }
34977 arg1 = reinterpret_cast< wxWindow * >(argp1);
34978 {
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 resultobj = SWIG_From_int(static_cast< int >(result));
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 bool result;
34995 void *argp1 = 0 ;
34996 int res1 = 0 ;
34997 PyObject *swig_obj[1] ;
34998
34999 if (!args) SWIG_fail;
35000 swig_obj[0] = args;
35001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35002 if (!SWIG_IsOK(res1)) {
35003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35004 }
35005 arg1 = reinterpret_cast< wxWindow * >(argp1);
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 result = (bool)(arg1)->HasTransparentBackground();
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 {
35013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35014 }
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35022 PyObject *resultobj = 0;
35023 wxWindow *arg1 = (wxWindow *) 0 ;
35024 wxCursor *arg2 = 0 ;
35025 bool result;
35026 void *argp1 = 0 ;
35027 int res1 = 0 ;
35028 void *argp2 = 0 ;
35029 int res2 = 0 ;
35030 PyObject * obj0 = 0 ;
35031 PyObject * obj1 = 0 ;
35032 char * kwnames[] = {
35033 (char *) "self",(char *) "cursor", NULL
35034 };
35035
35036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35038 if (!SWIG_IsOK(res1)) {
35039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35040 }
35041 arg1 = reinterpret_cast< wxWindow * >(argp1);
35042 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35043 if (!SWIG_IsOK(res2)) {
35044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35045 }
35046 if (!argp2) {
35047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35048 }
35049 arg2 = reinterpret_cast< wxCursor * >(argp2);
35050 {
35051 PyThreadState* __tstate = wxPyBeginAllowThreads();
35052 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35053 wxPyEndAllowThreads(__tstate);
35054 if (PyErr_Occurred()) SWIG_fail;
35055 }
35056 {
35057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35058 }
35059 return resultobj;
35060 fail:
35061 return NULL;
35062 }
35063
35064
35065 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35066 PyObject *resultobj = 0;
35067 wxWindow *arg1 = (wxWindow *) 0 ;
35068 wxCursor result;
35069 void *argp1 = 0 ;
35070 int res1 = 0 ;
35071 PyObject *swig_obj[1] ;
35072
35073 if (!args) SWIG_fail;
35074 swig_obj[0] = args;
35075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35076 if (!SWIG_IsOK(res1)) {
35077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35078 }
35079 arg1 = reinterpret_cast< wxWindow * >(argp1);
35080 {
35081 PyThreadState* __tstate = wxPyBeginAllowThreads();
35082 result = (arg1)->GetCursor();
35083 wxPyEndAllowThreads(__tstate);
35084 if (PyErr_Occurred()) SWIG_fail;
35085 }
35086 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35087 return resultobj;
35088 fail:
35089 return NULL;
35090 }
35091
35092
35093 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35094 PyObject *resultobj = 0;
35095 wxWindow *arg1 = (wxWindow *) 0 ;
35096 wxFont *arg2 = 0 ;
35097 bool result;
35098 void *argp1 = 0 ;
35099 int res1 = 0 ;
35100 void *argp2 = 0 ;
35101 int res2 = 0 ;
35102 PyObject * obj0 = 0 ;
35103 PyObject * obj1 = 0 ;
35104 char * kwnames[] = {
35105 (char *) "self",(char *) "font", NULL
35106 };
35107
35108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35112 }
35113 arg1 = reinterpret_cast< wxWindow * >(argp1);
35114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35115 if (!SWIG_IsOK(res2)) {
35116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35117 }
35118 if (!argp2) {
35119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35120 }
35121 arg2 = reinterpret_cast< wxFont * >(argp2);
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 {
35129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35130 }
35131 return resultobj;
35132 fail:
35133 return NULL;
35134 }
35135
35136
35137 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35138 PyObject *resultobj = 0;
35139 wxWindow *arg1 = (wxWindow *) 0 ;
35140 wxFont *arg2 = 0 ;
35141 void *argp1 = 0 ;
35142 int res1 = 0 ;
35143 void *argp2 = 0 ;
35144 int res2 = 0 ;
35145 PyObject * obj0 = 0 ;
35146 PyObject * obj1 = 0 ;
35147 char * kwnames[] = {
35148 (char *) "self",(char *) "font", NULL
35149 };
35150
35151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35153 if (!SWIG_IsOK(res1)) {
35154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35155 }
35156 arg1 = reinterpret_cast< wxWindow * >(argp1);
35157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35158 if (!SWIG_IsOK(res2)) {
35159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35160 }
35161 if (!argp2) {
35162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35163 }
35164 arg2 = reinterpret_cast< wxFont * >(argp2);
35165 {
35166 PyThreadState* __tstate = wxPyBeginAllowThreads();
35167 (arg1)->SetOwnFont((wxFont const &)*arg2);
35168 wxPyEndAllowThreads(__tstate);
35169 if (PyErr_Occurred()) SWIG_fail;
35170 }
35171 resultobj = SWIG_Py_Void();
35172 return resultobj;
35173 fail:
35174 return NULL;
35175 }
35176
35177
35178 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35179 PyObject *resultobj = 0;
35180 wxWindow *arg1 = (wxWindow *) 0 ;
35181 wxFont result;
35182 void *argp1 = 0 ;
35183 int res1 = 0 ;
35184 PyObject *swig_obj[1] ;
35185
35186 if (!args) SWIG_fail;
35187 swig_obj[0] = args;
35188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35189 if (!SWIG_IsOK(res1)) {
35190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35191 }
35192 arg1 = reinterpret_cast< wxWindow * >(argp1);
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 result = (arg1)->GetFont();
35196 wxPyEndAllowThreads(__tstate);
35197 if (PyErr_Occurred()) SWIG_fail;
35198 }
35199 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35200 return resultobj;
35201 fail:
35202 return NULL;
35203 }
35204
35205
35206 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35207 PyObject *resultobj = 0;
35208 wxWindow *arg1 = (wxWindow *) 0 ;
35209 wxCaret *arg2 = (wxCaret *) 0 ;
35210 void *argp1 = 0 ;
35211 int res1 = 0 ;
35212 int res2 = 0 ;
35213 PyObject * obj0 = 0 ;
35214 PyObject * obj1 = 0 ;
35215 char * kwnames[] = {
35216 (char *) "self",(char *) "caret", NULL
35217 };
35218
35219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35221 if (!SWIG_IsOK(res1)) {
35222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35223 }
35224 arg1 = reinterpret_cast< wxWindow * >(argp1);
35225 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35226 if (!SWIG_IsOK(res2)) {
35227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35228 }
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 (arg1)->SetCaret(arg2);
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_Py_Void();
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 wxCaret *result = 0 ;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 PyObject *swig_obj[1] ;
35249
35250 if (!args) SWIG_fail;
35251 swig_obj[0] = args;
35252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35253 if (!SWIG_IsOK(res1)) {
35254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35255 }
35256 arg1 = reinterpret_cast< wxWindow * >(argp1);
35257 {
35258 PyThreadState* __tstate = wxPyBeginAllowThreads();
35259 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35264 return resultobj;
35265 fail:
35266 return NULL;
35267 }
35268
35269
35270 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35271 PyObject *resultobj = 0;
35272 wxWindow *arg1 = (wxWindow *) 0 ;
35273 int result;
35274 void *argp1 = 0 ;
35275 int res1 = 0 ;
35276 PyObject *swig_obj[1] ;
35277
35278 if (!args) SWIG_fail;
35279 swig_obj[0] = args;
35280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35281 if (!SWIG_IsOK(res1)) {
35282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35283 }
35284 arg1 = reinterpret_cast< wxWindow * >(argp1);
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 resultobj = SWIG_From_int(static_cast< int >(result));
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 int result;
35302 void *argp1 = 0 ;
35303 int res1 = 0 ;
35304 PyObject *swig_obj[1] ;
35305
35306 if (!args) SWIG_fail;
35307 swig_obj[0] = args;
35308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35309 if (!SWIG_IsOK(res1)) {
35310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35311 }
35312 arg1 = reinterpret_cast< wxWindow * >(argp1);
35313 {
35314 PyThreadState* __tstate = wxPyBeginAllowThreads();
35315 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35316 wxPyEndAllowThreads(__tstate);
35317 if (PyErr_Occurred()) SWIG_fail;
35318 }
35319 resultobj = SWIG_From_int(static_cast< int >(result));
35320 return resultobj;
35321 fail:
35322 return NULL;
35323 }
35324
35325
35326 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj = 0;
35328 wxWindow *arg1 = (wxWindow *) 0 ;
35329 wxString *arg2 = 0 ;
35330 int *arg3 = (int *) 0 ;
35331 int *arg4 = (int *) 0 ;
35332 void *argp1 = 0 ;
35333 int res1 = 0 ;
35334 bool temp2 = false ;
35335 int temp3 ;
35336 int res3 = SWIG_TMPOBJ ;
35337 int temp4 ;
35338 int res4 = SWIG_TMPOBJ ;
35339 PyObject * obj0 = 0 ;
35340 PyObject * obj1 = 0 ;
35341 char * kwnames[] = {
35342 (char *) "self",(char *) "string", NULL
35343 };
35344
35345 arg3 = &temp3;
35346 arg4 = &temp4;
35347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35349 if (!SWIG_IsOK(res1)) {
35350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35351 }
35352 arg1 = reinterpret_cast< wxWindow * >(argp1);
35353 {
35354 arg2 = wxString_in_helper(obj1);
35355 if (arg2 == NULL) SWIG_fail;
35356 temp2 = true;
35357 }
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_Py_Void();
35365 if (SWIG_IsTmpObj(res3)) {
35366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35367 } else {
35368 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35370 }
35371 if (SWIG_IsTmpObj(res4)) {
35372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35373 } else {
35374 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35376 }
35377 {
35378 if (temp2)
35379 delete arg2;
35380 }
35381 return resultobj;
35382 fail:
35383 {
35384 if (temp2)
35385 delete arg2;
35386 }
35387 return NULL;
35388 }
35389
35390
35391 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35392 PyObject *resultobj = 0;
35393 wxWindow *arg1 = (wxWindow *) 0 ;
35394 wxString *arg2 = 0 ;
35395 int *arg3 = (int *) 0 ;
35396 int *arg4 = (int *) 0 ;
35397 int *arg5 = (int *) 0 ;
35398 int *arg6 = (int *) 0 ;
35399 wxFont *arg7 = (wxFont *) NULL ;
35400 void *argp1 = 0 ;
35401 int res1 = 0 ;
35402 bool temp2 = false ;
35403 int temp3 ;
35404 int res3 = SWIG_TMPOBJ ;
35405 int temp4 ;
35406 int res4 = SWIG_TMPOBJ ;
35407 int temp5 ;
35408 int res5 = SWIG_TMPOBJ ;
35409 int temp6 ;
35410 int res6 = SWIG_TMPOBJ ;
35411 void *argp7 = 0 ;
35412 int res7 = 0 ;
35413 PyObject * obj0 = 0 ;
35414 PyObject * obj1 = 0 ;
35415 PyObject * obj2 = 0 ;
35416 char * kwnames[] = {
35417 (char *) "self",(char *) "string",(char *) "font", NULL
35418 };
35419
35420 arg3 = &temp3;
35421 arg4 = &temp4;
35422 arg5 = &temp5;
35423 arg6 = &temp6;
35424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35426 if (!SWIG_IsOK(res1)) {
35427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35428 }
35429 arg1 = reinterpret_cast< wxWindow * >(argp1);
35430 {
35431 arg2 = wxString_in_helper(obj1);
35432 if (arg2 == NULL) SWIG_fail;
35433 temp2 = true;
35434 }
35435 if (obj2) {
35436 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35437 if (!SWIG_IsOK(res7)) {
35438 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35439 }
35440 arg7 = reinterpret_cast< wxFont * >(argp7);
35441 }
35442 {
35443 PyThreadState* __tstate = wxPyBeginAllowThreads();
35444 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 resultobj = SWIG_Py_Void();
35449 if (SWIG_IsTmpObj(res3)) {
35450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35451 } else {
35452 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35453 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35454 }
35455 if (SWIG_IsTmpObj(res4)) {
35456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35457 } else {
35458 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35460 }
35461 if (SWIG_IsTmpObj(res5)) {
35462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35463 } else {
35464 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35466 }
35467 if (SWIG_IsTmpObj(res6)) {
35468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35469 } else {
35470 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35472 }
35473 {
35474 if (temp2)
35475 delete arg2;
35476 }
35477 return resultobj;
35478 fail:
35479 {
35480 if (temp2)
35481 delete arg2;
35482 }
35483 return NULL;
35484 }
35485
35486
35487 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35488 PyObject *resultobj = 0;
35489 wxWindow *arg1 = (wxWindow *) 0 ;
35490 int *arg2 = (int *) 0 ;
35491 int *arg3 = (int *) 0 ;
35492 void *argp1 = 0 ;
35493 int res1 = 0 ;
35494 int temp2 ;
35495 int res2 = 0 ;
35496 int temp3 ;
35497 int res3 = 0 ;
35498 PyObject * obj0 = 0 ;
35499 PyObject * obj1 = 0 ;
35500 PyObject * obj2 = 0 ;
35501 char * kwnames[] = {
35502 (char *) "self",(char *) "x",(char *) "y", NULL
35503 };
35504
35505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35507 if (!SWIG_IsOK(res1)) {
35508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35509 }
35510 arg1 = reinterpret_cast< wxWindow * >(argp1);
35511 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35512 int val;
35513 int ecode = SWIG_AsVal_int(obj1, &val);
35514 if (!SWIG_IsOK(ecode)) {
35515 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35516 }
35517 temp2 = static_cast< int >(val);
35518 arg2 = &temp2;
35519 res2 = SWIG_AddTmpMask(ecode);
35520 }
35521 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35522 int val;
35523 int ecode = SWIG_AsVal_int(obj2, &val);
35524 if (!SWIG_IsOK(ecode)) {
35525 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35526 }
35527 temp3 = static_cast< int >(val);
35528 arg3 = &temp3;
35529 res3 = SWIG_AddTmpMask(ecode);
35530 }
35531 {
35532 PyThreadState* __tstate = wxPyBeginAllowThreads();
35533 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 resultobj = SWIG_Py_Void();
35538 if (SWIG_IsTmpObj(res2)) {
35539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35540 } else {
35541 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35543 }
35544 if (SWIG_IsTmpObj(res3)) {
35545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35546 } else {
35547 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35549 }
35550 return resultobj;
35551 fail:
35552 return NULL;
35553 }
35554
35555
35556 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35557 PyObject *resultobj = 0;
35558 wxWindow *arg1 = (wxWindow *) 0 ;
35559 int *arg2 = (int *) 0 ;
35560 int *arg3 = (int *) 0 ;
35561 void *argp1 = 0 ;
35562 int res1 = 0 ;
35563 int temp2 ;
35564 int res2 = 0 ;
35565 int temp3 ;
35566 int res3 = 0 ;
35567 PyObject * obj0 = 0 ;
35568 PyObject * obj1 = 0 ;
35569 PyObject * obj2 = 0 ;
35570 char * kwnames[] = {
35571 (char *) "self",(char *) "x",(char *) "y", NULL
35572 };
35573
35574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35576 if (!SWIG_IsOK(res1)) {
35577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35578 }
35579 arg1 = reinterpret_cast< wxWindow * >(argp1);
35580 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35581 int val;
35582 int ecode = SWIG_AsVal_int(obj1, &val);
35583 if (!SWIG_IsOK(ecode)) {
35584 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35585 }
35586 temp2 = static_cast< int >(val);
35587 arg2 = &temp2;
35588 res2 = SWIG_AddTmpMask(ecode);
35589 }
35590 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35591 int val;
35592 int ecode = SWIG_AsVal_int(obj2, &val);
35593 if (!SWIG_IsOK(ecode)) {
35594 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35595 }
35596 temp3 = static_cast< int >(val);
35597 arg3 = &temp3;
35598 res3 = SWIG_AddTmpMask(ecode);
35599 }
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 resultobj = SWIG_Py_Void();
35607 if (SWIG_IsTmpObj(res2)) {
35608 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35609 } else {
35610 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35611 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35612 }
35613 if (SWIG_IsTmpObj(res3)) {
35614 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35615 } else {
35616 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35617 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35618 }
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 wxPoint *arg2 = 0 ;
35629 wxPoint result;
35630 void *argp1 = 0 ;
35631 int res1 = 0 ;
35632 wxPoint temp2 ;
35633 PyObject * obj0 = 0 ;
35634 PyObject * obj1 = 0 ;
35635 char * kwnames[] = {
35636 (char *) "self",(char *) "pt", NULL
35637 };
35638
35639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35641 if (!SWIG_IsOK(res1)) {
35642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35643 }
35644 arg1 = reinterpret_cast< wxWindow * >(argp1);
35645 {
35646 arg2 = &temp2;
35647 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35648 }
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35656 return resultobj;
35657 fail:
35658 return NULL;
35659 }
35660
35661
35662 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35663 PyObject *resultobj = 0;
35664 wxWindow *arg1 = (wxWindow *) 0 ;
35665 wxPoint *arg2 = 0 ;
35666 wxPoint result;
35667 void *argp1 = 0 ;
35668 int res1 = 0 ;
35669 wxPoint temp2 ;
35670 PyObject * obj0 = 0 ;
35671 PyObject * obj1 = 0 ;
35672 char * kwnames[] = {
35673 (char *) "self",(char *) "pt", NULL
35674 };
35675
35676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35678 if (!SWIG_IsOK(res1)) {
35679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35680 }
35681 arg1 = reinterpret_cast< wxWindow * >(argp1);
35682 {
35683 arg2 = &temp2;
35684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35685 }
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35693 return resultobj;
35694 fail:
35695 return NULL;
35696 }
35697
35698
35699 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35700 PyObject *resultobj = 0;
35701 wxWindow *arg1 = (wxWindow *) 0 ;
35702 int arg2 ;
35703 int arg3 ;
35704 wxHitTest result;
35705 void *argp1 = 0 ;
35706 int res1 = 0 ;
35707 int val2 ;
35708 int ecode2 = 0 ;
35709 int val3 ;
35710 int ecode3 = 0 ;
35711 PyObject * obj0 = 0 ;
35712 PyObject * obj1 = 0 ;
35713 PyObject * obj2 = 0 ;
35714 char * kwnames[] = {
35715 (char *) "self",(char *) "x",(char *) "y", NULL
35716 };
35717
35718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 ecode2 = SWIG_AsVal_int(obj1, &val2);
35725 if (!SWIG_IsOK(ecode2)) {
35726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35727 }
35728 arg2 = static_cast< int >(val2);
35729 ecode3 = SWIG_AsVal_int(obj2, &val3);
35730 if (!SWIG_IsOK(ecode3)) {
35731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35732 }
35733 arg3 = static_cast< int >(val3);
35734 {
35735 PyThreadState* __tstate = wxPyBeginAllowThreads();
35736 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_From_int(static_cast< int >(result));
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35748 PyObject *resultobj = 0;
35749 wxWindow *arg1 = (wxWindow *) 0 ;
35750 wxPoint *arg2 = 0 ;
35751 wxHitTest result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 wxPoint temp2 ;
35755 PyObject * obj0 = 0 ;
35756 PyObject * obj1 = 0 ;
35757 char * kwnames[] = {
35758 (char *) "self",(char *) "pt", NULL
35759 };
35760
35761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35763 if (!SWIG_IsOK(res1)) {
35764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35765 }
35766 arg1 = reinterpret_cast< wxWindow * >(argp1);
35767 {
35768 arg2 = &temp2;
35769 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35774 wxPyEndAllowThreads(__tstate);
35775 if (PyErr_Occurred()) SWIG_fail;
35776 }
35777 resultobj = SWIG_From_int(static_cast< int >(result));
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 long arg2 ;
35788 wxBorder result;
35789 void *argp1 = 0 ;
35790 int res1 = 0 ;
35791 long val2 ;
35792 int ecode2 = 0 ;
35793
35794 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35796 if (!SWIG_IsOK(res1)) {
35797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35798 }
35799 arg1 = reinterpret_cast< wxWindow * >(argp1);
35800 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35801 if (!SWIG_IsOK(ecode2)) {
35802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35803 }
35804 arg2 = static_cast< long >(val2);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 resultobj = SWIG_From_int(static_cast< int >(result));
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 wxBorder result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824
35825 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35827 if (!SWIG_IsOK(res1)) {
35828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35829 }
35830 arg1 = reinterpret_cast< wxWindow * >(argp1);
35831 {
35832 PyThreadState* __tstate = wxPyBeginAllowThreads();
35833 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35834 wxPyEndAllowThreads(__tstate);
35835 if (PyErr_Occurred()) SWIG_fail;
35836 }
35837 resultobj = SWIG_From_int(static_cast< int >(result));
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35845 int argc;
35846 PyObject *argv[3];
35847
35848 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35849 --argc;
35850 if (argc == 1) {
35851 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35852 }
35853 if (argc == 2) {
35854 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35855 }
35856
35857 fail:
35858 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35859 return NULL;
35860 }
35861
35862
35863 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35864 PyObject *resultobj = 0;
35865 wxWindow *arg1 = (wxWindow *) 0 ;
35866 long arg2 = (long) wxUPDATE_UI_NONE ;
35867 void *argp1 = 0 ;
35868 int res1 = 0 ;
35869 long val2 ;
35870 int ecode2 = 0 ;
35871 PyObject * obj0 = 0 ;
35872 PyObject * obj1 = 0 ;
35873 char * kwnames[] = {
35874 (char *) "self",(char *) "flags", NULL
35875 };
35876
35877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35879 if (!SWIG_IsOK(res1)) {
35880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35881 }
35882 arg1 = reinterpret_cast< wxWindow * >(argp1);
35883 if (obj1) {
35884 ecode2 = SWIG_AsVal_long(obj1, &val2);
35885 if (!SWIG_IsOK(ecode2)) {
35886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35887 }
35888 arg2 = static_cast< long >(val2);
35889 }
35890 {
35891 PyThreadState* __tstate = wxPyBeginAllowThreads();
35892 (arg1)->UpdateWindowUI(arg2);
35893 wxPyEndAllowThreads(__tstate);
35894 if (PyErr_Occurred()) SWIG_fail;
35895 }
35896 resultobj = SWIG_Py_Void();
35897 return resultobj;
35898 fail:
35899 return NULL;
35900 }
35901
35902
35903 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35904 PyObject *resultobj = 0;
35905 wxWindow *arg1 = (wxWindow *) 0 ;
35906 wxMenu *arg2 = (wxMenu *) 0 ;
35907 int arg3 = (int) -1 ;
35908 int arg4 = (int) -1 ;
35909 bool result;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 void *argp2 = 0 ;
35913 int res2 = 0 ;
35914 int val3 ;
35915 int ecode3 = 0 ;
35916 int val4 ;
35917 int ecode4 = 0 ;
35918 PyObject * obj0 = 0 ;
35919 PyObject * obj1 = 0 ;
35920 PyObject * obj2 = 0 ;
35921 PyObject * obj3 = 0 ;
35922 char * kwnames[] = {
35923 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35924 };
35925
35926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35928 if (!SWIG_IsOK(res1)) {
35929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35930 }
35931 arg1 = reinterpret_cast< wxWindow * >(argp1);
35932 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35933 if (!SWIG_IsOK(res2)) {
35934 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35935 }
35936 arg2 = reinterpret_cast< wxMenu * >(argp2);
35937 if (obj2) {
35938 ecode3 = SWIG_AsVal_int(obj2, &val3);
35939 if (!SWIG_IsOK(ecode3)) {
35940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35941 }
35942 arg3 = static_cast< int >(val3);
35943 }
35944 if (obj3) {
35945 ecode4 = SWIG_AsVal_int(obj3, &val4);
35946 if (!SWIG_IsOK(ecode4)) {
35947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35948 }
35949 arg4 = static_cast< int >(val4);
35950 }
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 {
35958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35959 }
35960 return resultobj;
35961 fail:
35962 return NULL;
35963 }
35964
35965
35966 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35967 PyObject *resultobj = 0;
35968 wxWindow *arg1 = (wxWindow *) 0 ;
35969 wxMenu *arg2 = (wxMenu *) 0 ;
35970 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35971 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35972 bool result;
35973 void *argp1 = 0 ;
35974 int res1 = 0 ;
35975 void *argp2 = 0 ;
35976 int res2 = 0 ;
35977 wxPoint temp3 ;
35978 PyObject * obj0 = 0 ;
35979 PyObject * obj1 = 0 ;
35980 PyObject * obj2 = 0 ;
35981 char * kwnames[] = {
35982 (char *) "self",(char *) "menu",(char *) "pos", NULL
35983 };
35984
35985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35989 }
35990 arg1 = reinterpret_cast< wxWindow * >(argp1);
35991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35992 if (!SWIG_IsOK(res2)) {
35993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35994 }
35995 arg2 = reinterpret_cast< wxMenu * >(argp2);
35996 if (obj2) {
35997 {
35998 arg3 = &temp3;
35999 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36000 }
36001 }
36002 {
36003 PyThreadState* __tstate = wxPyBeginAllowThreads();
36004 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36005 wxPyEndAllowThreads(__tstate);
36006 if (PyErr_Occurred()) SWIG_fail;
36007 }
36008 {
36009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36010 }
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36018 PyObject *resultobj = 0;
36019 wxWindow *arg1 = (wxWindow *) 0 ;
36020 long result;
36021 void *argp1 = 0 ;
36022 int res1 = 0 ;
36023 PyObject *swig_obj[1] ;
36024
36025 if (!args) SWIG_fail;
36026 swig_obj[0] = args;
36027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 result = (long)wxWindow_GetHandle(arg1);
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 resultobj = SWIG_From_long(static_cast< long >(result));
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36046 PyObject *resultobj = 0;
36047 wxWindow *arg1 = (wxWindow *) 0 ;
36048 long arg2 ;
36049 void *argp1 = 0 ;
36050 int res1 = 0 ;
36051 long val2 ;
36052 int ecode2 = 0 ;
36053 PyObject * obj0 = 0 ;
36054 PyObject * obj1 = 0 ;
36055 char * kwnames[] = {
36056 (char *) "self",(char *) "handle", NULL
36057 };
36058
36059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36061 if (!SWIG_IsOK(res1)) {
36062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36063 }
36064 arg1 = reinterpret_cast< wxWindow * >(argp1);
36065 ecode2 = SWIG_AsVal_long(obj1, &val2);
36066 if (!SWIG_IsOK(ecode2)) {
36067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36068 }
36069 arg2 = static_cast< long >(val2);
36070 {
36071 PyThreadState* __tstate = wxPyBeginAllowThreads();
36072 wxWindow_AssociateHandle(arg1,arg2);
36073 wxPyEndAllowThreads(__tstate);
36074 if (PyErr_Occurred()) SWIG_fail;
36075 }
36076 resultobj = SWIG_Py_Void();
36077 return resultobj;
36078 fail:
36079 return NULL;
36080 }
36081
36082
36083 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36084 PyObject *resultobj = 0;
36085 wxWindow *arg1 = (wxWindow *) 0 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 PyObject *swig_obj[1] ;
36089
36090 if (!args) SWIG_fail;
36091 swig_obj[0] = args;
36092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36093 if (!SWIG_IsOK(res1)) {
36094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36095 }
36096 arg1 = reinterpret_cast< wxWindow * >(argp1);
36097 {
36098 PyThreadState* __tstate = wxPyBeginAllowThreads();
36099 (arg1)->DissociateHandle();
36100 wxPyEndAllowThreads(__tstate);
36101 if (PyErr_Occurred()) SWIG_fail;
36102 }
36103 resultobj = SWIG_Py_Void();
36104 return resultobj;
36105 fail:
36106 return NULL;
36107 }
36108
36109
36110 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj = 0;
36112 wxWindow *arg1 = (wxWindow *) 0 ;
36113 wxPaintEvent *arg2 = 0 ;
36114 void *argp1 = 0 ;
36115 int res1 = 0 ;
36116 void *argp2 = 0 ;
36117 int res2 = 0 ;
36118 PyObject * obj0 = 0 ;
36119 PyObject * obj1 = 0 ;
36120 char * kwnames[] = {
36121 (char *) "self",(char *) "event", NULL
36122 };
36123
36124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36126 if (!SWIG_IsOK(res1)) {
36127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36128 }
36129 arg1 = reinterpret_cast< wxWindow * >(argp1);
36130 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36131 if (!SWIG_IsOK(res2)) {
36132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36133 }
36134 if (!argp2) {
36135 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36136 }
36137 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36138 {
36139 PyThreadState* __tstate = wxPyBeginAllowThreads();
36140 (arg1)->OnPaint(*arg2);
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 resultobj = SWIG_Py_Void();
36145 return resultobj;
36146 fail:
36147 return NULL;
36148 }
36149
36150
36151 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36152 PyObject *resultobj = 0;
36153 wxWindow *arg1 = (wxWindow *) 0 ;
36154 int arg2 ;
36155 bool result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158 int val2 ;
36159 int ecode2 = 0 ;
36160 PyObject * obj0 = 0 ;
36161 PyObject * obj1 = 0 ;
36162 char * kwnames[] = {
36163 (char *) "self",(char *) "orient", NULL
36164 };
36165
36166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36168 if (!SWIG_IsOK(res1)) {
36169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36170 }
36171 arg1 = reinterpret_cast< wxWindow * >(argp1);
36172 ecode2 = SWIG_AsVal_int(obj1, &val2);
36173 if (!SWIG_IsOK(ecode2)) {
36174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36175 }
36176 arg2 = static_cast< int >(val2);
36177 {
36178 PyThreadState* __tstate = wxPyBeginAllowThreads();
36179 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36180 wxPyEndAllowThreads(__tstate);
36181 if (PyErr_Occurred()) SWIG_fail;
36182 }
36183 {
36184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36185 }
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36193 PyObject *resultobj = 0;
36194 wxWindow *arg1 = (wxWindow *) 0 ;
36195 int arg2 ;
36196 int arg3 ;
36197 int arg4 ;
36198 int arg5 ;
36199 bool arg6 = (bool) true ;
36200 void *argp1 = 0 ;
36201 int res1 = 0 ;
36202 int val2 ;
36203 int ecode2 = 0 ;
36204 int val3 ;
36205 int ecode3 = 0 ;
36206 int val4 ;
36207 int ecode4 = 0 ;
36208 int val5 ;
36209 int ecode5 = 0 ;
36210 bool val6 ;
36211 int ecode6 = 0 ;
36212 PyObject * obj0 = 0 ;
36213 PyObject * obj1 = 0 ;
36214 PyObject * obj2 = 0 ;
36215 PyObject * obj3 = 0 ;
36216 PyObject * obj4 = 0 ;
36217 PyObject * obj5 = 0 ;
36218 char * kwnames[] = {
36219 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36220 };
36221
36222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36224 if (!SWIG_IsOK(res1)) {
36225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36226 }
36227 arg1 = reinterpret_cast< wxWindow * >(argp1);
36228 ecode2 = SWIG_AsVal_int(obj1, &val2);
36229 if (!SWIG_IsOK(ecode2)) {
36230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36231 }
36232 arg2 = static_cast< int >(val2);
36233 ecode3 = SWIG_AsVal_int(obj2, &val3);
36234 if (!SWIG_IsOK(ecode3)) {
36235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36236 }
36237 arg3 = static_cast< int >(val3);
36238 ecode4 = SWIG_AsVal_int(obj3, &val4);
36239 if (!SWIG_IsOK(ecode4)) {
36240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36241 }
36242 arg4 = static_cast< int >(val4);
36243 ecode5 = SWIG_AsVal_int(obj4, &val5);
36244 if (!SWIG_IsOK(ecode5)) {
36245 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36246 }
36247 arg5 = static_cast< int >(val5);
36248 if (obj5) {
36249 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36250 if (!SWIG_IsOK(ecode6)) {
36251 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36252 }
36253 arg6 = static_cast< bool >(val6);
36254 }
36255 {
36256 PyThreadState* __tstate = wxPyBeginAllowThreads();
36257 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36258 wxPyEndAllowThreads(__tstate);
36259 if (PyErr_Occurred()) SWIG_fail;
36260 }
36261 resultobj = SWIG_Py_Void();
36262 return resultobj;
36263 fail:
36264 return NULL;
36265 }
36266
36267
36268 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36269 PyObject *resultobj = 0;
36270 wxWindow *arg1 = (wxWindow *) 0 ;
36271 int arg2 ;
36272 int arg3 ;
36273 bool arg4 = (bool) true ;
36274 void *argp1 = 0 ;
36275 int res1 = 0 ;
36276 int val2 ;
36277 int ecode2 = 0 ;
36278 int val3 ;
36279 int ecode3 = 0 ;
36280 bool val4 ;
36281 int ecode4 = 0 ;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 PyObject * obj2 = 0 ;
36285 PyObject * obj3 = 0 ;
36286 char * kwnames[] = {
36287 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36288 };
36289
36290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36292 if (!SWIG_IsOK(res1)) {
36293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36294 }
36295 arg1 = reinterpret_cast< wxWindow * >(argp1);
36296 ecode2 = SWIG_AsVal_int(obj1, &val2);
36297 if (!SWIG_IsOK(ecode2)) {
36298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36299 }
36300 arg2 = static_cast< int >(val2);
36301 ecode3 = SWIG_AsVal_int(obj2, &val3);
36302 if (!SWIG_IsOK(ecode3)) {
36303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36304 }
36305 arg3 = static_cast< int >(val3);
36306 if (obj3) {
36307 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36308 if (!SWIG_IsOK(ecode4)) {
36309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36310 }
36311 arg4 = static_cast< bool >(val4);
36312 }
36313 {
36314 PyThreadState* __tstate = wxPyBeginAllowThreads();
36315 (arg1)->SetScrollPos(arg2,arg3,arg4);
36316 wxPyEndAllowThreads(__tstate);
36317 if (PyErr_Occurred()) SWIG_fail;
36318 }
36319 resultobj = SWIG_Py_Void();
36320 return resultobj;
36321 fail:
36322 return NULL;
36323 }
36324
36325
36326 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36327 PyObject *resultobj = 0;
36328 wxWindow *arg1 = (wxWindow *) 0 ;
36329 int arg2 ;
36330 int result;
36331 void *argp1 = 0 ;
36332 int res1 = 0 ;
36333 int val2 ;
36334 int ecode2 = 0 ;
36335 PyObject * obj0 = 0 ;
36336 PyObject * obj1 = 0 ;
36337 char * kwnames[] = {
36338 (char *) "self",(char *) "orientation", NULL
36339 };
36340
36341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36343 if (!SWIG_IsOK(res1)) {
36344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36345 }
36346 arg1 = reinterpret_cast< wxWindow * >(argp1);
36347 ecode2 = SWIG_AsVal_int(obj1, &val2);
36348 if (!SWIG_IsOK(ecode2)) {
36349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36350 }
36351 arg2 = static_cast< int >(val2);
36352 {
36353 PyThreadState* __tstate = wxPyBeginAllowThreads();
36354 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36355 wxPyEndAllowThreads(__tstate);
36356 if (PyErr_Occurred()) SWIG_fail;
36357 }
36358 resultobj = SWIG_From_int(static_cast< int >(result));
36359 return resultobj;
36360 fail:
36361 return NULL;
36362 }
36363
36364
36365 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36366 PyObject *resultobj = 0;
36367 wxWindow *arg1 = (wxWindow *) 0 ;
36368 int arg2 ;
36369 int result;
36370 void *argp1 = 0 ;
36371 int res1 = 0 ;
36372 int val2 ;
36373 int ecode2 = 0 ;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char * kwnames[] = {
36377 (char *) "self",(char *) "orientation", NULL
36378 };
36379
36380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36382 if (!SWIG_IsOK(res1)) {
36383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36384 }
36385 arg1 = reinterpret_cast< wxWindow * >(argp1);
36386 ecode2 = SWIG_AsVal_int(obj1, &val2);
36387 if (!SWIG_IsOK(ecode2)) {
36388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36389 }
36390 arg2 = static_cast< int >(val2);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 resultobj = SWIG_From_int(static_cast< int >(result));
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 int arg2 ;
36408 int result;
36409 void *argp1 = 0 ;
36410 int res1 = 0 ;
36411 int val2 ;
36412 int ecode2 = 0 ;
36413 PyObject * obj0 = 0 ;
36414 PyObject * obj1 = 0 ;
36415 char * kwnames[] = {
36416 (char *) "self",(char *) "orientation", NULL
36417 };
36418
36419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36421 if (!SWIG_IsOK(res1)) {
36422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36423 }
36424 arg1 = reinterpret_cast< wxWindow * >(argp1);
36425 ecode2 = SWIG_AsVal_int(obj1, &val2);
36426 if (!SWIG_IsOK(ecode2)) {
36427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36428 }
36429 arg2 = static_cast< int >(val2);
36430 {
36431 PyThreadState* __tstate = wxPyBeginAllowThreads();
36432 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36433 wxPyEndAllowThreads(__tstate);
36434 if (PyErr_Occurred()) SWIG_fail;
36435 }
36436 resultobj = SWIG_From_int(static_cast< int >(result));
36437 return resultobj;
36438 fail:
36439 return NULL;
36440 }
36441
36442
36443 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36444 PyObject *resultobj = 0;
36445 wxWindow *arg1 = (wxWindow *) 0 ;
36446 int arg2 ;
36447 int arg3 ;
36448 wxRect *arg4 = (wxRect *) NULL ;
36449 void *argp1 = 0 ;
36450 int res1 = 0 ;
36451 int val2 ;
36452 int ecode2 = 0 ;
36453 int val3 ;
36454 int ecode3 = 0 ;
36455 void *argp4 = 0 ;
36456 int res4 = 0 ;
36457 PyObject * obj0 = 0 ;
36458 PyObject * obj1 = 0 ;
36459 PyObject * obj2 = 0 ;
36460 PyObject * obj3 = 0 ;
36461 char * kwnames[] = {
36462 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36463 };
36464
36465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36467 if (!SWIG_IsOK(res1)) {
36468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36469 }
36470 arg1 = reinterpret_cast< wxWindow * >(argp1);
36471 ecode2 = SWIG_AsVal_int(obj1, &val2);
36472 if (!SWIG_IsOK(ecode2)) {
36473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36474 }
36475 arg2 = static_cast< int >(val2);
36476 ecode3 = SWIG_AsVal_int(obj2, &val3);
36477 if (!SWIG_IsOK(ecode3)) {
36478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36479 }
36480 arg3 = static_cast< int >(val3);
36481 if (obj3) {
36482 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36483 if (!SWIG_IsOK(res4)) {
36484 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36485 }
36486 arg4 = reinterpret_cast< wxRect * >(argp4);
36487 }
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 resultobj = SWIG_Py_Void();
36495 return resultobj;
36496 fail:
36497 return NULL;
36498 }
36499
36500
36501 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36502 PyObject *resultobj = 0;
36503 wxWindow *arg1 = (wxWindow *) 0 ;
36504 int arg2 ;
36505 bool result;
36506 void *argp1 = 0 ;
36507 int res1 = 0 ;
36508 int val2 ;
36509 int ecode2 = 0 ;
36510 PyObject * obj0 = 0 ;
36511 PyObject * obj1 = 0 ;
36512 char * kwnames[] = {
36513 (char *) "self",(char *) "lines", NULL
36514 };
36515
36516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36518 if (!SWIG_IsOK(res1)) {
36519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36520 }
36521 arg1 = reinterpret_cast< wxWindow * >(argp1);
36522 ecode2 = SWIG_AsVal_int(obj1, &val2);
36523 if (!SWIG_IsOK(ecode2)) {
36524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36525 }
36526 arg2 = static_cast< int >(val2);
36527 {
36528 PyThreadState* __tstate = wxPyBeginAllowThreads();
36529 result = (bool)(arg1)->ScrollLines(arg2);
36530 wxPyEndAllowThreads(__tstate);
36531 if (PyErr_Occurred()) SWIG_fail;
36532 }
36533 {
36534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36535 }
36536 return resultobj;
36537 fail:
36538 return NULL;
36539 }
36540
36541
36542 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36543 PyObject *resultobj = 0;
36544 wxWindow *arg1 = (wxWindow *) 0 ;
36545 int arg2 ;
36546 bool result;
36547 void *argp1 = 0 ;
36548 int res1 = 0 ;
36549 int val2 ;
36550 int ecode2 = 0 ;
36551 PyObject * obj0 = 0 ;
36552 PyObject * obj1 = 0 ;
36553 char * kwnames[] = {
36554 (char *) "self",(char *) "pages", NULL
36555 };
36556
36557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36559 if (!SWIG_IsOK(res1)) {
36560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36561 }
36562 arg1 = reinterpret_cast< wxWindow * >(argp1);
36563 ecode2 = SWIG_AsVal_int(obj1, &val2);
36564 if (!SWIG_IsOK(ecode2)) {
36565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36566 }
36567 arg2 = static_cast< int >(val2);
36568 {
36569 PyThreadState* __tstate = wxPyBeginAllowThreads();
36570 result = (bool)(arg1)->ScrollPages(arg2);
36571 wxPyEndAllowThreads(__tstate);
36572 if (PyErr_Occurred()) SWIG_fail;
36573 }
36574 {
36575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36576 }
36577 return resultobj;
36578 fail:
36579 return NULL;
36580 }
36581
36582
36583 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36584 PyObject *resultobj = 0;
36585 wxWindow *arg1 = (wxWindow *) 0 ;
36586 bool result;
36587 void *argp1 = 0 ;
36588 int res1 = 0 ;
36589 PyObject *swig_obj[1] ;
36590
36591 if (!args) SWIG_fail;
36592 swig_obj[0] = args;
36593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36594 if (!SWIG_IsOK(res1)) {
36595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36596 }
36597 arg1 = reinterpret_cast< wxWindow * >(argp1);
36598 {
36599 PyThreadState* __tstate = wxPyBeginAllowThreads();
36600 result = (bool)(arg1)->LineUp();
36601 wxPyEndAllowThreads(__tstate);
36602 if (PyErr_Occurred()) SWIG_fail;
36603 }
36604 {
36605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36606 }
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 bool result;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (bool)(arg1)->LineDown();
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 {
36635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36636 }
36637 return resultobj;
36638 fail:
36639 return NULL;
36640 }
36641
36642
36643 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36644 PyObject *resultobj = 0;
36645 wxWindow *arg1 = (wxWindow *) 0 ;
36646 bool result;
36647 void *argp1 = 0 ;
36648 int res1 = 0 ;
36649 PyObject *swig_obj[1] ;
36650
36651 if (!args) SWIG_fail;
36652 swig_obj[0] = args;
36653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36654 if (!SWIG_IsOK(res1)) {
36655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36656 }
36657 arg1 = reinterpret_cast< wxWindow * >(argp1);
36658 {
36659 PyThreadState* __tstate = wxPyBeginAllowThreads();
36660 result = (bool)(arg1)->PageUp();
36661 wxPyEndAllowThreads(__tstate);
36662 if (PyErr_Occurred()) SWIG_fail;
36663 }
36664 {
36665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36666 }
36667 return resultobj;
36668 fail:
36669 return NULL;
36670 }
36671
36672
36673 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36674 PyObject *resultobj = 0;
36675 wxWindow *arg1 = (wxWindow *) 0 ;
36676 bool result;
36677 void *argp1 = 0 ;
36678 int res1 = 0 ;
36679 PyObject *swig_obj[1] ;
36680
36681 if (!args) SWIG_fail;
36682 swig_obj[0] = args;
36683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36684 if (!SWIG_IsOK(res1)) {
36685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36686 }
36687 arg1 = reinterpret_cast< wxWindow * >(argp1);
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 result = (bool)(arg1)->PageDown();
36691 wxPyEndAllowThreads(__tstate);
36692 if (PyErr_Occurred()) SWIG_fail;
36693 }
36694 {
36695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36696 }
36697 return resultobj;
36698 fail:
36699 return NULL;
36700 }
36701
36702
36703 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36704 PyObject *resultobj = 0;
36705 wxWindow *arg1 = (wxWindow *) 0 ;
36706 wxString *arg2 = 0 ;
36707 void *argp1 = 0 ;
36708 int res1 = 0 ;
36709 bool temp2 = false ;
36710 PyObject * obj0 = 0 ;
36711 PyObject * obj1 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "text", NULL
36714 };
36715
36716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",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_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36720 }
36721 arg1 = reinterpret_cast< wxWindow * >(argp1);
36722 {
36723 arg2 = wxString_in_helper(obj1);
36724 if (arg2 == NULL) SWIG_fail;
36725 temp2 = true;
36726 }
36727 {
36728 PyThreadState* __tstate = wxPyBeginAllowThreads();
36729 (arg1)->SetHelpText((wxString const &)*arg2);
36730 wxPyEndAllowThreads(__tstate);
36731 if (PyErr_Occurred()) SWIG_fail;
36732 }
36733 resultobj = SWIG_Py_Void();
36734 {
36735 if (temp2)
36736 delete arg2;
36737 }
36738 return resultobj;
36739 fail:
36740 {
36741 if (temp2)
36742 delete arg2;
36743 }
36744 return NULL;
36745 }
36746
36747
36748 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36749 PyObject *resultobj = 0;
36750 wxWindow *arg1 = (wxWindow *) 0 ;
36751 wxString *arg2 = 0 ;
36752 void *argp1 = 0 ;
36753 int res1 = 0 ;
36754 bool temp2 = false ;
36755 PyObject * obj0 = 0 ;
36756 PyObject * obj1 = 0 ;
36757 char * kwnames[] = {
36758 (char *) "self",(char *) "text", NULL
36759 };
36760
36761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36763 if (!SWIG_IsOK(res1)) {
36764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36765 }
36766 arg1 = reinterpret_cast< wxWindow * >(argp1);
36767 {
36768 arg2 = wxString_in_helper(obj1);
36769 if (arg2 == NULL) SWIG_fail;
36770 temp2 = true;
36771 }
36772 {
36773 PyThreadState* __tstate = wxPyBeginAllowThreads();
36774 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36775 wxPyEndAllowThreads(__tstate);
36776 if (PyErr_Occurred()) SWIG_fail;
36777 }
36778 resultobj = SWIG_Py_Void();
36779 {
36780 if (temp2)
36781 delete arg2;
36782 }
36783 return resultobj;
36784 fail:
36785 {
36786 if (temp2)
36787 delete arg2;
36788 }
36789 return NULL;
36790 }
36791
36792
36793 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36794 PyObject *resultobj = 0;
36795 wxWindow *arg1 = (wxWindow *) 0 ;
36796 wxString result;
36797 void *argp1 = 0 ;
36798 int res1 = 0 ;
36799 PyObject *swig_obj[1] ;
36800
36801 if (!args) SWIG_fail;
36802 swig_obj[0] = args;
36803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36804 if (!SWIG_IsOK(res1)) {
36805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36806 }
36807 arg1 = reinterpret_cast< wxWindow * >(argp1);
36808 {
36809 PyThreadState* __tstate = wxPyBeginAllowThreads();
36810 result = ((wxWindow const *)arg1)->GetHelpText();
36811 wxPyEndAllowThreads(__tstate);
36812 if (PyErr_Occurred()) SWIG_fail;
36813 }
36814 {
36815 #if wxUSE_UNICODE
36816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36817 #else
36818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36819 #endif
36820 }
36821 return resultobj;
36822 fail:
36823 return NULL;
36824 }
36825
36826
36827 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36828 PyObject *resultobj = 0;
36829 wxWindow *arg1 = (wxWindow *) 0 ;
36830 wxString *arg2 = 0 ;
36831 void *argp1 = 0 ;
36832 int res1 = 0 ;
36833 bool temp2 = false ;
36834 PyObject * obj0 = 0 ;
36835 PyObject * obj1 = 0 ;
36836 char * kwnames[] = {
36837 (char *) "self",(char *) "tip", NULL
36838 };
36839
36840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36842 if (!SWIG_IsOK(res1)) {
36843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36844 }
36845 arg1 = reinterpret_cast< wxWindow * >(argp1);
36846 {
36847 arg2 = wxString_in_helper(obj1);
36848 if (arg2 == NULL) SWIG_fail;
36849 temp2 = true;
36850 }
36851 {
36852 PyThreadState* __tstate = wxPyBeginAllowThreads();
36853 (arg1)->SetToolTip((wxString const &)*arg2);
36854 wxPyEndAllowThreads(__tstate);
36855 if (PyErr_Occurred()) SWIG_fail;
36856 }
36857 resultobj = SWIG_Py_Void();
36858 {
36859 if (temp2)
36860 delete arg2;
36861 }
36862 return resultobj;
36863 fail:
36864 {
36865 if (temp2)
36866 delete arg2;
36867 }
36868 return NULL;
36869 }
36870
36871
36872 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36873 PyObject *resultobj = 0;
36874 wxWindow *arg1 = (wxWindow *) 0 ;
36875 wxToolTip *arg2 = (wxToolTip *) 0 ;
36876 void *argp1 = 0 ;
36877 int res1 = 0 ;
36878 int res2 = 0 ;
36879 PyObject * obj0 = 0 ;
36880 PyObject * obj1 = 0 ;
36881 char * kwnames[] = {
36882 (char *) "self",(char *) "tip", NULL
36883 };
36884
36885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36887 if (!SWIG_IsOK(res1)) {
36888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36889 }
36890 arg1 = reinterpret_cast< wxWindow * >(argp1);
36891 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36892 if (!SWIG_IsOK(res2)) {
36893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36894 }
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 (arg1)->SetToolTip(arg2);
36898 wxPyEndAllowThreads(__tstate);
36899 if (PyErr_Occurred()) SWIG_fail;
36900 }
36901 resultobj = SWIG_Py_Void();
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36909 PyObject *resultobj = 0;
36910 wxWindow *arg1 = (wxWindow *) 0 ;
36911 wxToolTip *result = 0 ;
36912 void *argp1 = 0 ;
36913 int res1 = 0 ;
36914 PyObject *swig_obj[1] ;
36915
36916 if (!args) SWIG_fail;
36917 swig_obj[0] = args;
36918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36919 if (!SWIG_IsOK(res1)) {
36920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36921 }
36922 arg1 = reinterpret_cast< wxWindow * >(argp1);
36923 {
36924 PyThreadState* __tstate = wxPyBeginAllowThreads();
36925 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 {
36930 resultobj = wxPyMake_wxObject(result, (bool)0);
36931 }
36932 return resultobj;
36933 fail:
36934 return NULL;
36935 }
36936
36937
36938 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36939 PyObject *resultobj = 0;
36940 wxWindow *arg1 = (wxWindow *) 0 ;
36941 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36942 void *argp1 = 0 ;
36943 int res1 = 0 ;
36944 int res2 = 0 ;
36945 PyObject * obj0 = 0 ;
36946 PyObject * obj1 = 0 ;
36947 char * kwnames[] = {
36948 (char *) "self",(char *) "dropTarget", NULL
36949 };
36950
36951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36953 if (!SWIG_IsOK(res1)) {
36954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36955 }
36956 arg1 = reinterpret_cast< wxWindow * >(argp1);
36957 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36958 if (!SWIG_IsOK(res2)) {
36959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36960 }
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 (arg1)->SetDropTarget(arg2);
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 resultobj = SWIG_Py_Void();
36968 return resultobj;
36969 fail:
36970 return NULL;
36971 }
36972
36973
36974 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36975 PyObject *resultobj = 0;
36976 wxWindow *arg1 = (wxWindow *) 0 ;
36977 wxPyDropTarget *result = 0 ;
36978 void *argp1 = 0 ;
36979 int res1 = 0 ;
36980 PyObject *swig_obj[1] ;
36981
36982 if (!args) SWIG_fail;
36983 swig_obj[0] = args;
36984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36985 if (!SWIG_IsOK(res1)) {
36986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36987 }
36988 arg1 = reinterpret_cast< wxWindow * >(argp1);
36989 {
36990 PyThreadState* __tstate = wxPyBeginAllowThreads();
36991 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36992 wxPyEndAllowThreads(__tstate);
36993 if (PyErr_Occurred()) SWIG_fail;
36994 }
36995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36996 return resultobj;
36997 fail:
36998 return NULL;
36999 }
37000
37001
37002 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37003 PyObject *resultobj = 0;
37004 wxWindow *arg1 = (wxWindow *) 0 ;
37005 bool arg2 ;
37006 void *argp1 = 0 ;
37007 int res1 = 0 ;
37008 bool val2 ;
37009 int ecode2 = 0 ;
37010 PyObject * obj0 = 0 ;
37011 PyObject * obj1 = 0 ;
37012 char * kwnames[] = {
37013 (char *) "self",(char *) "accept", NULL
37014 };
37015
37016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37018 if (!SWIG_IsOK(res1)) {
37019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37020 }
37021 arg1 = reinterpret_cast< wxWindow * >(argp1);
37022 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37023 if (!SWIG_IsOK(ecode2)) {
37024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37025 }
37026 arg2 = static_cast< bool >(val2);
37027 {
37028 PyThreadState* __tstate = wxPyBeginAllowThreads();
37029 (arg1)->DragAcceptFiles(arg2);
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 resultobj = SWIG_Py_Void();
37034 return resultobj;
37035 fail:
37036 return NULL;
37037 }
37038
37039
37040 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37041 PyObject *resultobj = 0;
37042 wxWindow *arg1 = (wxWindow *) 0 ;
37043 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37044 void *argp1 = 0 ;
37045 int res1 = 0 ;
37046 int res2 = 0 ;
37047 PyObject * obj0 = 0 ;
37048 PyObject * obj1 = 0 ;
37049 char * kwnames[] = {
37050 (char *) "self",(char *) "constraints", NULL
37051 };
37052
37053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37055 if (!SWIG_IsOK(res1)) {
37056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37057 }
37058 arg1 = reinterpret_cast< wxWindow * >(argp1);
37059 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37060 if (!SWIG_IsOK(res2)) {
37061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37062 }
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 (arg1)->SetConstraints(arg2);
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 resultobj = SWIG_Py_Void();
37070 return resultobj;
37071 fail:
37072 return NULL;
37073 }
37074
37075
37076 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37077 PyObject *resultobj = 0;
37078 wxWindow *arg1 = (wxWindow *) 0 ;
37079 wxLayoutConstraints *result = 0 ;
37080 void *argp1 = 0 ;
37081 int res1 = 0 ;
37082 PyObject *swig_obj[1] ;
37083
37084 if (!args) SWIG_fail;
37085 swig_obj[0] = args;
37086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37087 if (!SWIG_IsOK(res1)) {
37088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37089 }
37090 arg1 = reinterpret_cast< wxWindow * >(argp1);
37091 {
37092 PyThreadState* __tstate = wxPyBeginAllowThreads();
37093 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37094 wxPyEndAllowThreads(__tstate);
37095 if (PyErr_Occurred()) SWIG_fail;
37096 }
37097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj = 0;
37106 wxWindow *arg1 = (wxWindow *) 0 ;
37107 bool arg2 ;
37108 void *argp1 = 0 ;
37109 int res1 = 0 ;
37110 bool val2 ;
37111 int ecode2 = 0 ;
37112 PyObject * obj0 = 0 ;
37113 PyObject * obj1 = 0 ;
37114 char * kwnames[] = {
37115 (char *) "self",(char *) "autoLayout", NULL
37116 };
37117
37118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37120 if (!SWIG_IsOK(res1)) {
37121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37122 }
37123 arg1 = reinterpret_cast< wxWindow * >(argp1);
37124 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37125 if (!SWIG_IsOK(ecode2)) {
37126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37127 }
37128 arg2 = static_cast< bool >(val2);
37129 {
37130 PyThreadState* __tstate = wxPyBeginAllowThreads();
37131 (arg1)->SetAutoLayout(arg2);
37132 wxPyEndAllowThreads(__tstate);
37133 if (PyErr_Occurred()) SWIG_fail;
37134 }
37135 resultobj = SWIG_Py_Void();
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 bool result;
37146 void *argp1 = 0 ;
37147 int res1 = 0 ;
37148 PyObject *swig_obj[1] ;
37149
37150 if (!args) SWIG_fail;
37151 swig_obj[0] = args;
37152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37153 if (!SWIG_IsOK(res1)) {
37154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37155 }
37156 arg1 = reinterpret_cast< wxWindow * >(argp1);
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 {
37164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37165 }
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 bool result;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 PyObject *swig_obj[1] ;
37179
37180 if (!args) SWIG_fail;
37181 swig_obj[0] = args;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (bool)(arg1)->Layout();
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 {
37194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37203 PyObject *resultobj = 0;
37204 wxWindow *arg1 = (wxWindow *) 0 ;
37205 wxSizer *arg2 = (wxSizer *) 0 ;
37206 bool arg3 = (bool) true ;
37207 void *argp1 = 0 ;
37208 int res1 = 0 ;
37209 int res2 = 0 ;
37210 bool val3 ;
37211 int ecode3 = 0 ;
37212 PyObject * obj0 = 0 ;
37213 PyObject * obj1 = 0 ;
37214 PyObject * obj2 = 0 ;
37215 char * kwnames[] = {
37216 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37217 };
37218
37219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37221 if (!SWIG_IsOK(res1)) {
37222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37223 }
37224 arg1 = reinterpret_cast< wxWindow * >(argp1);
37225 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37226 if (!SWIG_IsOK(res2)) {
37227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37228 }
37229 if (obj2) {
37230 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37231 if (!SWIG_IsOK(ecode3)) {
37232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37233 }
37234 arg3 = static_cast< bool >(val3);
37235 }
37236 {
37237 PyThreadState* __tstate = wxPyBeginAllowThreads();
37238 (arg1)->SetSizer(arg2,arg3);
37239 wxPyEndAllowThreads(__tstate);
37240 if (PyErr_Occurred()) SWIG_fail;
37241 }
37242 resultobj = SWIG_Py_Void();
37243 return resultobj;
37244 fail:
37245 return NULL;
37246 }
37247
37248
37249 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37250 PyObject *resultobj = 0;
37251 wxWindow *arg1 = (wxWindow *) 0 ;
37252 wxSizer *arg2 = (wxSizer *) 0 ;
37253 bool arg3 = (bool) true ;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 int res2 = 0 ;
37257 bool val3 ;
37258 int ecode3 = 0 ;
37259 PyObject * obj0 = 0 ;
37260 PyObject * obj1 = 0 ;
37261 PyObject * obj2 = 0 ;
37262 char * kwnames[] = {
37263 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37264 };
37265
37266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37270 }
37271 arg1 = reinterpret_cast< wxWindow * >(argp1);
37272 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37273 if (!SWIG_IsOK(res2)) {
37274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37275 }
37276 if (obj2) {
37277 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37278 if (!SWIG_IsOK(ecode3)) {
37279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37280 }
37281 arg3 = static_cast< bool >(val3);
37282 }
37283 {
37284 PyThreadState* __tstate = wxPyBeginAllowThreads();
37285 (arg1)->SetSizerAndFit(arg2,arg3);
37286 wxPyEndAllowThreads(__tstate);
37287 if (PyErr_Occurred()) SWIG_fail;
37288 }
37289 resultobj = SWIG_Py_Void();
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37297 PyObject *resultobj = 0;
37298 wxWindow *arg1 = (wxWindow *) 0 ;
37299 wxSizer *result = 0 ;
37300 void *argp1 = 0 ;
37301 int res1 = 0 ;
37302 PyObject *swig_obj[1] ;
37303
37304 if (!args) SWIG_fail;
37305 swig_obj[0] = args;
37306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37314 wxPyEndAllowThreads(__tstate);
37315 if (PyErr_Occurred()) SWIG_fail;
37316 }
37317 {
37318 resultobj = wxPyMake_wxObject(result, (bool)0);
37319 }
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 wxSizer *arg2 = (wxSizer *) 0 ;
37330 void *argp1 = 0 ;
37331 int res1 = 0 ;
37332 void *argp2 = 0 ;
37333 int res2 = 0 ;
37334 PyObject * obj0 = 0 ;
37335 PyObject * obj1 = 0 ;
37336 char * kwnames[] = {
37337 (char *) "self",(char *) "sizer", NULL
37338 };
37339
37340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37342 if (!SWIG_IsOK(res1)) {
37343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37344 }
37345 arg1 = reinterpret_cast< wxWindow * >(argp1);
37346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37347 if (!SWIG_IsOK(res2)) {
37348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37349 }
37350 arg2 = reinterpret_cast< wxSizer * >(argp2);
37351 {
37352 PyThreadState* __tstate = wxPyBeginAllowThreads();
37353 (arg1)->SetContainingSizer(arg2);
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 resultobj = SWIG_Py_Void();
37358 return resultobj;
37359 fail:
37360 return NULL;
37361 }
37362
37363
37364 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37365 PyObject *resultobj = 0;
37366 wxWindow *arg1 = (wxWindow *) 0 ;
37367 wxSizer *result = 0 ;
37368 void *argp1 = 0 ;
37369 int res1 = 0 ;
37370 PyObject *swig_obj[1] ;
37371
37372 if (!args) SWIG_fail;
37373 swig_obj[0] = args;
37374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37375 if (!SWIG_IsOK(res1)) {
37376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37377 }
37378 arg1 = reinterpret_cast< wxWindow * >(argp1);
37379 {
37380 PyThreadState* __tstate = wxPyBeginAllowThreads();
37381 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37382 wxPyEndAllowThreads(__tstate);
37383 if (PyErr_Occurred()) SWIG_fail;
37384 }
37385 {
37386 resultobj = wxPyMake_wxObject(result, (bool)0);
37387 }
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 PyObject *swig_obj[1] ;
37400
37401 if (!args) SWIG_fail;
37402 swig_obj[0] = args;
37403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37406 }
37407 arg1 = reinterpret_cast< wxWindow * >(argp1);
37408 {
37409 PyThreadState* __tstate = wxPyBeginAllowThreads();
37410 (arg1)->InheritAttributes();
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 resultobj = SWIG_Py_Void();
37415 return resultobj;
37416 fail:
37417 return NULL;
37418 }
37419
37420
37421 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37422 PyObject *resultobj = 0;
37423 wxWindow *arg1 = (wxWindow *) 0 ;
37424 bool result;
37425 void *argp1 = 0 ;
37426 int res1 = 0 ;
37427 PyObject *swig_obj[1] ;
37428
37429 if (!args) SWIG_fail;
37430 swig_obj[0] = args;
37431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37432 if (!SWIG_IsOK(res1)) {
37433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37434 }
37435 arg1 = reinterpret_cast< wxWindow * >(argp1);
37436 {
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 {
37443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37444 }
37445 return resultobj;
37446 fail:
37447 return NULL;
37448 }
37449
37450
37451 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37452 PyObject *obj;
37453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37454 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37455 return SWIG_Py_Void();
37456 }
37457
37458 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37459 return SWIG_Python_InitShadowInstance(args);
37460 }
37461
37462 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37463 PyObject *resultobj = 0;
37464 long arg1 ;
37465 wxWindow *arg2 = (wxWindow *) NULL ;
37466 wxWindow *result = 0 ;
37467 long val1 ;
37468 int ecode1 = 0 ;
37469 void *argp2 = 0 ;
37470 int res2 = 0 ;
37471 PyObject * obj0 = 0 ;
37472 PyObject * obj1 = 0 ;
37473 char * kwnames[] = {
37474 (char *) "id",(char *) "parent", NULL
37475 };
37476
37477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37478 ecode1 = SWIG_AsVal_long(obj0, &val1);
37479 if (!SWIG_IsOK(ecode1)) {
37480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37481 }
37482 arg1 = static_cast< long >(val1);
37483 if (obj1) {
37484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37485 if (!SWIG_IsOK(res2)) {
37486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37487 }
37488 arg2 = reinterpret_cast< wxWindow * >(argp2);
37489 }
37490 {
37491 if (!wxPyCheckForApp()) SWIG_fail;
37492 PyThreadState* __tstate = wxPyBeginAllowThreads();
37493 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37494 wxPyEndAllowThreads(__tstate);
37495 if (PyErr_Occurred()) SWIG_fail;
37496 }
37497 {
37498 resultobj = wxPyMake_wxObject(result, 0);
37499 }
37500 return resultobj;
37501 fail:
37502 return NULL;
37503 }
37504
37505
37506 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37507 PyObject *resultobj = 0;
37508 wxString *arg1 = 0 ;
37509 wxWindow *arg2 = (wxWindow *) NULL ;
37510 wxWindow *result = 0 ;
37511 bool temp1 = false ;
37512 void *argp2 = 0 ;
37513 int res2 = 0 ;
37514 PyObject * obj0 = 0 ;
37515 PyObject * obj1 = 0 ;
37516 char * kwnames[] = {
37517 (char *) "name",(char *) "parent", NULL
37518 };
37519
37520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37521 {
37522 arg1 = wxString_in_helper(obj0);
37523 if (arg1 == NULL) SWIG_fail;
37524 temp1 = true;
37525 }
37526 if (obj1) {
37527 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37528 if (!SWIG_IsOK(res2)) {
37529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37530 }
37531 arg2 = reinterpret_cast< wxWindow * >(argp2);
37532 }
37533 {
37534 if (!wxPyCheckForApp()) SWIG_fail;
37535 PyThreadState* __tstate = wxPyBeginAllowThreads();
37536 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37537 wxPyEndAllowThreads(__tstate);
37538 if (PyErr_Occurred()) SWIG_fail;
37539 }
37540 {
37541 resultobj = wxPyMake_wxObject(result, 0);
37542 }
37543 {
37544 if (temp1)
37545 delete arg1;
37546 }
37547 return resultobj;
37548 fail:
37549 {
37550 if (temp1)
37551 delete arg1;
37552 }
37553 return NULL;
37554 }
37555
37556
37557 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37558 PyObject *resultobj = 0;
37559 wxString *arg1 = 0 ;
37560 wxWindow *arg2 = (wxWindow *) NULL ;
37561 wxWindow *result = 0 ;
37562 bool temp1 = false ;
37563 void *argp2 = 0 ;
37564 int res2 = 0 ;
37565 PyObject * obj0 = 0 ;
37566 PyObject * obj1 = 0 ;
37567 char * kwnames[] = {
37568 (char *) "label",(char *) "parent", NULL
37569 };
37570
37571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37572 {
37573 arg1 = wxString_in_helper(obj0);
37574 if (arg1 == NULL) SWIG_fail;
37575 temp1 = true;
37576 }
37577 if (obj1) {
37578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37579 if (!SWIG_IsOK(res2)) {
37580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37581 }
37582 arg2 = reinterpret_cast< wxWindow * >(argp2);
37583 }
37584 {
37585 if (!wxPyCheckForApp()) SWIG_fail;
37586 PyThreadState* __tstate = wxPyBeginAllowThreads();
37587 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37588 wxPyEndAllowThreads(__tstate);
37589 if (PyErr_Occurred()) SWIG_fail;
37590 }
37591 {
37592 resultobj = wxPyMake_wxObject(result, 0);
37593 }
37594 {
37595 if (temp1)
37596 delete arg1;
37597 }
37598 return resultobj;
37599 fail:
37600 {
37601 if (temp1)
37602 delete arg1;
37603 }
37604 return NULL;
37605 }
37606
37607
37608 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37609 PyObject *resultobj = 0;
37610 wxWindow *arg1 = (wxWindow *) 0 ;
37611 unsigned long arg2 ;
37612 wxWindow *result = 0 ;
37613 void *argp1 = 0 ;
37614 int res1 = 0 ;
37615 unsigned long val2 ;
37616 int ecode2 = 0 ;
37617 PyObject * obj0 = 0 ;
37618 PyObject * obj1 = 0 ;
37619 char * kwnames[] = {
37620 (char *) "parent",(char *) "_hWnd", NULL
37621 };
37622
37623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37625 if (!SWIG_IsOK(res1)) {
37626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37627 }
37628 arg1 = reinterpret_cast< wxWindow * >(argp1);
37629 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37630 if (!SWIG_IsOK(ecode2)) {
37631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37632 }
37633 arg2 = static_cast< unsigned long >(val2);
37634 {
37635 PyThreadState* __tstate = wxPyBeginAllowThreads();
37636 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37637 wxPyEndAllowThreads(__tstate);
37638 if (PyErr_Occurred()) SWIG_fail;
37639 }
37640 {
37641 resultobj = wxPyMake_wxObject(result, 0);
37642 }
37643 return resultobj;
37644 fail:
37645 return NULL;
37646 }
37647
37648
37649 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37650 PyObject *resultobj = 0;
37651 PyObject *result = 0 ;
37652
37653 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (PyObject *)GetTopLevelWindows();
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 resultobj = result;
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37668 PyObject *resultobj = 0;
37669 wxValidator *result = 0 ;
37670
37671 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37672 {
37673 PyThreadState* __tstate = wxPyBeginAllowThreads();
37674 result = (wxValidator *)new wxValidator();
37675 wxPyEndAllowThreads(__tstate);
37676 if (PyErr_Occurred()) SWIG_fail;
37677 }
37678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37679 return resultobj;
37680 fail:
37681 return NULL;
37682 }
37683
37684
37685 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37686 PyObject *resultobj = 0;
37687 wxValidator *arg1 = (wxValidator *) 0 ;
37688 wxValidator *result = 0 ;
37689 void *argp1 = 0 ;
37690 int res1 = 0 ;
37691 PyObject *swig_obj[1] ;
37692
37693 if (!args) SWIG_fail;
37694 swig_obj[0] = args;
37695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37696 if (!SWIG_IsOK(res1)) {
37697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37698 }
37699 arg1 = reinterpret_cast< wxValidator * >(argp1);
37700 {
37701 PyThreadState* __tstate = wxPyBeginAllowThreads();
37702 result = (wxValidator *)(arg1)->Clone();
37703 wxPyEndAllowThreads(__tstate);
37704 if (PyErr_Occurred()) SWIG_fail;
37705 }
37706 {
37707 resultobj = wxPyMake_wxObject(result, 0);
37708 }
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37716 PyObject *resultobj = 0;
37717 wxValidator *arg1 = (wxValidator *) 0 ;
37718 wxWindow *arg2 = (wxWindow *) 0 ;
37719 bool result;
37720 void *argp1 = 0 ;
37721 int res1 = 0 ;
37722 void *argp2 = 0 ;
37723 int res2 = 0 ;
37724 PyObject * obj0 = 0 ;
37725 PyObject * obj1 = 0 ;
37726 char * kwnames[] = {
37727 (char *) "self",(char *) "parent", NULL
37728 };
37729
37730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37732 if (!SWIG_IsOK(res1)) {
37733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37734 }
37735 arg1 = reinterpret_cast< wxValidator * >(argp1);
37736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37737 if (!SWIG_IsOK(res2)) {
37738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37739 }
37740 arg2 = reinterpret_cast< wxWindow * >(argp2);
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = (bool)(arg1)->Validate(arg2);
37744 wxPyEndAllowThreads(__tstate);
37745 if (PyErr_Occurred()) SWIG_fail;
37746 }
37747 {
37748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37749 }
37750 return resultobj;
37751 fail:
37752 return NULL;
37753 }
37754
37755
37756 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37757 PyObject *resultobj = 0;
37758 wxValidator *arg1 = (wxValidator *) 0 ;
37759 bool result;
37760 void *argp1 = 0 ;
37761 int res1 = 0 ;
37762 PyObject *swig_obj[1] ;
37763
37764 if (!args) SWIG_fail;
37765 swig_obj[0] = args;
37766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37767 if (!SWIG_IsOK(res1)) {
37768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37769 }
37770 arg1 = reinterpret_cast< wxValidator * >(argp1);
37771 {
37772 PyThreadState* __tstate = wxPyBeginAllowThreads();
37773 result = (bool)(arg1)->TransferToWindow();
37774 wxPyEndAllowThreads(__tstate);
37775 if (PyErr_Occurred()) SWIG_fail;
37776 }
37777 {
37778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37779 }
37780 return resultobj;
37781 fail:
37782 return NULL;
37783 }
37784
37785
37786 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37787 PyObject *resultobj = 0;
37788 wxValidator *arg1 = (wxValidator *) 0 ;
37789 bool result;
37790 void *argp1 = 0 ;
37791 int res1 = 0 ;
37792 PyObject *swig_obj[1] ;
37793
37794 if (!args) SWIG_fail;
37795 swig_obj[0] = args;
37796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37799 }
37800 arg1 = reinterpret_cast< wxValidator * >(argp1);
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 result = (bool)(arg1)->TransferFromWindow();
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 {
37808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37809 }
37810 return resultobj;
37811 fail:
37812 return NULL;
37813 }
37814
37815
37816 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37817 PyObject *resultobj = 0;
37818 wxValidator *arg1 = (wxValidator *) 0 ;
37819 wxWindow *result = 0 ;
37820 void *argp1 = 0 ;
37821 int res1 = 0 ;
37822 PyObject *swig_obj[1] ;
37823
37824 if (!args) SWIG_fail;
37825 swig_obj[0] = args;
37826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37827 if (!SWIG_IsOK(res1)) {
37828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37829 }
37830 arg1 = reinterpret_cast< wxValidator * >(argp1);
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 result = (wxWindow *)(arg1)->GetWindow();
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 {
37838 resultobj = wxPyMake_wxObject(result, 0);
37839 }
37840 return resultobj;
37841 fail:
37842 return NULL;
37843 }
37844
37845
37846 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37847 PyObject *resultobj = 0;
37848 wxValidator *arg1 = (wxValidator *) 0 ;
37849 wxWindow *arg2 = (wxWindow *) 0 ;
37850 void *argp1 = 0 ;
37851 int res1 = 0 ;
37852 void *argp2 = 0 ;
37853 int res2 = 0 ;
37854 PyObject * obj0 = 0 ;
37855 PyObject * obj1 = 0 ;
37856 char * kwnames[] = {
37857 (char *) "self",(char *) "window", NULL
37858 };
37859
37860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37862 if (!SWIG_IsOK(res1)) {
37863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37864 }
37865 arg1 = reinterpret_cast< wxValidator * >(argp1);
37866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37867 if (!SWIG_IsOK(res2)) {
37868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37869 }
37870 arg2 = reinterpret_cast< wxWindow * >(argp2);
37871 {
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 (arg1)->SetWindow(arg2);
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 resultobj = SWIG_Py_Void();
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37885 PyObject *resultobj = 0;
37886 bool result;
37887
37888 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37889 {
37890 PyThreadState* __tstate = wxPyBeginAllowThreads();
37891 result = (bool)wxValidator::IsSilent();
37892 wxPyEndAllowThreads(__tstate);
37893 if (PyErr_Occurred()) SWIG_fail;
37894 }
37895 {
37896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37897 }
37898 return resultobj;
37899 fail:
37900 return NULL;
37901 }
37902
37903
37904 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37905 PyObject *resultobj = 0;
37906 int arg1 = (int) true ;
37907 int val1 ;
37908 int ecode1 = 0 ;
37909 PyObject * obj0 = 0 ;
37910 char * kwnames[] = {
37911 (char *) "doIt", NULL
37912 };
37913
37914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37915 if (obj0) {
37916 ecode1 = SWIG_AsVal_int(obj0, &val1);
37917 if (!SWIG_IsOK(ecode1)) {
37918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37919 }
37920 arg1 = static_cast< int >(val1);
37921 }
37922 {
37923 PyThreadState* __tstate = wxPyBeginAllowThreads();
37924 wxValidator::SetBellOnError(arg1);
37925 wxPyEndAllowThreads(__tstate);
37926 if (PyErr_Occurred()) SWIG_fail;
37927 }
37928 resultobj = SWIG_Py_Void();
37929 return resultobj;
37930 fail:
37931 return NULL;
37932 }
37933
37934
37935 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37936 PyObject *obj;
37937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37938 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37939 return SWIG_Py_Void();
37940 }
37941
37942 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37943 return SWIG_Python_InitShadowInstance(args);
37944 }
37945
37946 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37947 PyObject *resultobj = 0;
37948 wxPyValidator *result = 0 ;
37949
37950 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37951 {
37952 PyThreadState* __tstate = wxPyBeginAllowThreads();
37953 result = (wxPyValidator *)new wxPyValidator();
37954 wxPyEndAllowThreads(__tstate);
37955 if (PyErr_Occurred()) SWIG_fail;
37956 }
37957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37958 return resultobj;
37959 fail:
37960 return NULL;
37961 }
37962
37963
37964 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37965 PyObject *resultobj = 0;
37966 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37967 PyObject *arg2 = (PyObject *) 0 ;
37968 PyObject *arg3 = (PyObject *) 0 ;
37969 int arg4 = (int) true ;
37970 void *argp1 = 0 ;
37971 int res1 = 0 ;
37972 int val4 ;
37973 int ecode4 = 0 ;
37974 PyObject * obj0 = 0 ;
37975 PyObject * obj1 = 0 ;
37976 PyObject * obj2 = 0 ;
37977 PyObject * obj3 = 0 ;
37978 char * kwnames[] = {
37979 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37980 };
37981
37982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37984 if (!SWIG_IsOK(res1)) {
37985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37986 }
37987 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37988 arg2 = obj1;
37989 arg3 = obj2;
37990 if (obj3) {
37991 ecode4 = SWIG_AsVal_int(obj3, &val4);
37992 if (!SWIG_IsOK(ecode4)) {
37993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37994 }
37995 arg4 = static_cast< int >(val4);
37996 }
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38000 wxPyEndAllowThreads(__tstate);
38001 if (PyErr_Occurred()) SWIG_fail;
38002 }
38003 resultobj = SWIG_Py_Void();
38004 return resultobj;
38005 fail:
38006 return NULL;
38007 }
38008
38009
38010 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38011 PyObject *obj;
38012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38013 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38014 return SWIG_Py_Void();
38015 }
38016
38017 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38018 return SWIG_Python_InitShadowInstance(args);
38019 }
38020
38021 SWIGINTERN int DefaultValidator_set(PyObject *) {
38022 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38023 return 1;
38024 }
38025
38026
38027 SWIGINTERN PyObject *DefaultValidator_get(void) {
38028 PyObject *pyobj = 0;
38029
38030 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38031 return pyobj;
38032 }
38033
38034
38035 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38036 PyObject *resultobj = 0;
38037 wxString const &arg1_defvalue = wxPyEmptyString ;
38038 wxString *arg1 = (wxString *) &arg1_defvalue ;
38039 long arg2 = (long) 0 ;
38040 wxMenu *result = 0 ;
38041 bool temp1 = false ;
38042 long val2 ;
38043 int ecode2 = 0 ;
38044 PyObject * obj0 = 0 ;
38045 PyObject * obj1 = 0 ;
38046 char * kwnames[] = {
38047 (char *) "title",(char *) "style", NULL
38048 };
38049
38050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38051 if (obj0) {
38052 {
38053 arg1 = wxString_in_helper(obj0);
38054 if (arg1 == NULL) SWIG_fail;
38055 temp1 = true;
38056 }
38057 }
38058 if (obj1) {
38059 ecode2 = SWIG_AsVal_long(obj1, &val2);
38060 if (!SWIG_IsOK(ecode2)) {
38061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38062 }
38063 arg2 = static_cast< long >(val2);
38064 }
38065 {
38066 if (!wxPyCheckForApp()) SWIG_fail;
38067 PyThreadState* __tstate = wxPyBeginAllowThreads();
38068 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38069 wxPyEndAllowThreads(__tstate);
38070 if (PyErr_Occurred()) SWIG_fail;
38071 }
38072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38073 {
38074 if (temp1)
38075 delete arg1;
38076 }
38077 return resultobj;
38078 fail:
38079 {
38080 if (temp1)
38081 delete arg1;
38082 }
38083 return NULL;
38084 }
38085
38086
38087 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38088 PyObject *resultobj = 0;
38089 wxMenu *arg1 = (wxMenu *) 0 ;
38090 int arg2 ;
38091 wxString *arg3 = 0 ;
38092 wxString const &arg4_defvalue = wxPyEmptyString ;
38093 wxString *arg4 = (wxString *) &arg4_defvalue ;
38094 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38095 wxMenuItem *result = 0 ;
38096 void *argp1 = 0 ;
38097 int res1 = 0 ;
38098 int val2 ;
38099 int ecode2 = 0 ;
38100 bool temp3 = false ;
38101 bool temp4 = false ;
38102 int val5 ;
38103 int ecode5 = 0 ;
38104 PyObject * obj0 = 0 ;
38105 PyObject * obj1 = 0 ;
38106 PyObject * obj2 = 0 ;
38107 PyObject * obj3 = 0 ;
38108 PyObject * obj4 = 0 ;
38109 char * kwnames[] = {
38110 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38111 };
38112
38113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38115 if (!SWIG_IsOK(res1)) {
38116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38117 }
38118 arg1 = reinterpret_cast< wxMenu * >(argp1);
38119 ecode2 = SWIG_AsVal_int(obj1, &val2);
38120 if (!SWIG_IsOK(ecode2)) {
38121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38122 }
38123 arg2 = static_cast< int >(val2);
38124 {
38125 arg3 = wxString_in_helper(obj2);
38126 if (arg3 == NULL) SWIG_fail;
38127 temp3 = true;
38128 }
38129 if (obj3) {
38130 {
38131 arg4 = wxString_in_helper(obj3);
38132 if (arg4 == NULL) SWIG_fail;
38133 temp4 = true;
38134 }
38135 }
38136 if (obj4) {
38137 ecode5 = SWIG_AsVal_int(obj4, &val5);
38138 if (!SWIG_IsOK(ecode5)) {
38139 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38140 }
38141 arg5 = static_cast< wxItemKind >(val5);
38142 }
38143 {
38144 PyThreadState* __tstate = wxPyBeginAllowThreads();
38145 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38146 wxPyEndAllowThreads(__tstate);
38147 if (PyErr_Occurred()) SWIG_fail;
38148 }
38149 {
38150 resultobj = wxPyMake_wxObject(result, (bool)0);
38151 }
38152 {
38153 if (temp3)
38154 delete arg3;
38155 }
38156 {
38157 if (temp4)
38158 delete arg4;
38159 }
38160 return resultobj;
38161 fail:
38162 {
38163 if (temp3)
38164 delete arg3;
38165 }
38166 {
38167 if (temp4)
38168 delete arg4;
38169 }
38170 return NULL;
38171 }
38172
38173
38174 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38175 PyObject *resultobj = 0;
38176 wxMenu *arg1 = (wxMenu *) 0 ;
38177 wxMenuItem *result = 0 ;
38178 void *argp1 = 0 ;
38179 int res1 = 0 ;
38180 PyObject *swig_obj[1] ;
38181
38182 if (!args) SWIG_fail;
38183 swig_obj[0] = args;
38184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38185 if (!SWIG_IsOK(res1)) {
38186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38187 }
38188 arg1 = reinterpret_cast< wxMenu * >(argp1);
38189 {
38190 PyThreadState* __tstate = wxPyBeginAllowThreads();
38191 result = (wxMenuItem *)(arg1)->AppendSeparator();
38192 wxPyEndAllowThreads(__tstate);
38193 if (PyErr_Occurred()) SWIG_fail;
38194 }
38195 {
38196 resultobj = wxPyMake_wxObject(result, (bool)0);
38197 }
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj = 0;
38206 wxMenu *arg1 = (wxMenu *) 0 ;
38207 int arg2 ;
38208 wxString *arg3 = 0 ;
38209 wxString const &arg4_defvalue = wxPyEmptyString ;
38210 wxString *arg4 = (wxString *) &arg4_defvalue ;
38211 wxMenuItem *result = 0 ;
38212 void *argp1 = 0 ;
38213 int res1 = 0 ;
38214 int val2 ;
38215 int ecode2 = 0 ;
38216 bool temp3 = false ;
38217 bool temp4 = false ;
38218 PyObject * obj0 = 0 ;
38219 PyObject * obj1 = 0 ;
38220 PyObject * obj2 = 0 ;
38221 PyObject * obj3 = 0 ;
38222 char * kwnames[] = {
38223 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38224 };
38225
38226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38228 if (!SWIG_IsOK(res1)) {
38229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38230 }
38231 arg1 = reinterpret_cast< wxMenu * >(argp1);
38232 ecode2 = SWIG_AsVal_int(obj1, &val2);
38233 if (!SWIG_IsOK(ecode2)) {
38234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38235 }
38236 arg2 = static_cast< int >(val2);
38237 {
38238 arg3 = wxString_in_helper(obj2);
38239 if (arg3 == NULL) SWIG_fail;
38240 temp3 = true;
38241 }
38242 if (obj3) {
38243 {
38244 arg4 = wxString_in_helper(obj3);
38245 if (arg4 == NULL) SWIG_fail;
38246 temp4 = true;
38247 }
38248 }
38249 {
38250 PyThreadState* __tstate = wxPyBeginAllowThreads();
38251 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38252 wxPyEndAllowThreads(__tstate);
38253 if (PyErr_Occurred()) SWIG_fail;
38254 }
38255 {
38256 resultobj = wxPyMake_wxObject(result, (bool)0);
38257 }
38258 {
38259 if (temp3)
38260 delete arg3;
38261 }
38262 {
38263 if (temp4)
38264 delete arg4;
38265 }
38266 return resultobj;
38267 fail:
38268 {
38269 if (temp3)
38270 delete arg3;
38271 }
38272 {
38273 if (temp4)
38274 delete arg4;
38275 }
38276 return NULL;
38277 }
38278
38279
38280 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38281 PyObject *resultobj = 0;
38282 wxMenu *arg1 = (wxMenu *) 0 ;
38283 int arg2 ;
38284 wxString *arg3 = 0 ;
38285 wxString const &arg4_defvalue = wxPyEmptyString ;
38286 wxString *arg4 = (wxString *) &arg4_defvalue ;
38287 wxMenuItem *result = 0 ;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 int val2 ;
38291 int ecode2 = 0 ;
38292 bool temp3 = false ;
38293 bool temp4 = false ;
38294 PyObject * obj0 = 0 ;
38295 PyObject * obj1 = 0 ;
38296 PyObject * obj2 = 0 ;
38297 PyObject * obj3 = 0 ;
38298 char * kwnames[] = {
38299 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38300 };
38301
38302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38304 if (!SWIG_IsOK(res1)) {
38305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38306 }
38307 arg1 = reinterpret_cast< wxMenu * >(argp1);
38308 ecode2 = SWIG_AsVal_int(obj1, &val2);
38309 if (!SWIG_IsOK(ecode2)) {
38310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38311 }
38312 arg2 = static_cast< int >(val2);
38313 {
38314 arg3 = wxString_in_helper(obj2);
38315 if (arg3 == NULL) SWIG_fail;
38316 temp3 = true;
38317 }
38318 if (obj3) {
38319 {
38320 arg4 = wxString_in_helper(obj3);
38321 if (arg4 == NULL) SWIG_fail;
38322 temp4 = true;
38323 }
38324 }
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 {
38332 resultobj = wxPyMake_wxObject(result, (bool)0);
38333 }
38334 {
38335 if (temp3)
38336 delete arg3;
38337 }
38338 {
38339 if (temp4)
38340 delete arg4;
38341 }
38342 return resultobj;
38343 fail:
38344 {
38345 if (temp3)
38346 delete arg3;
38347 }
38348 {
38349 if (temp4)
38350 delete arg4;
38351 }
38352 return NULL;
38353 }
38354
38355
38356 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38357 PyObject *resultobj = 0;
38358 wxMenu *arg1 = (wxMenu *) 0 ;
38359 int arg2 ;
38360 wxString *arg3 = 0 ;
38361 wxMenu *arg4 = (wxMenu *) 0 ;
38362 wxString const &arg5_defvalue = wxPyEmptyString ;
38363 wxString *arg5 = (wxString *) &arg5_defvalue ;
38364 wxMenuItem *result = 0 ;
38365 void *argp1 = 0 ;
38366 int res1 = 0 ;
38367 int val2 ;
38368 int ecode2 = 0 ;
38369 bool temp3 = false ;
38370 void *argp4 = 0 ;
38371 int res4 = 0 ;
38372 bool temp5 = false ;
38373 PyObject * obj0 = 0 ;
38374 PyObject * obj1 = 0 ;
38375 PyObject * obj2 = 0 ;
38376 PyObject * obj3 = 0 ;
38377 PyObject * obj4 = 0 ;
38378 char * kwnames[] = {
38379 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38380 };
38381
38382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38384 if (!SWIG_IsOK(res1)) {
38385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38386 }
38387 arg1 = reinterpret_cast< wxMenu * >(argp1);
38388 ecode2 = SWIG_AsVal_int(obj1, &val2);
38389 if (!SWIG_IsOK(ecode2)) {
38390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38391 }
38392 arg2 = static_cast< int >(val2);
38393 {
38394 arg3 = wxString_in_helper(obj2);
38395 if (arg3 == NULL) SWIG_fail;
38396 temp3 = true;
38397 }
38398 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38399 if (!SWIG_IsOK(res4)) {
38400 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38401 }
38402 arg4 = reinterpret_cast< wxMenu * >(argp4);
38403 if (obj4) {
38404 {
38405 arg5 = wxString_in_helper(obj4);
38406 if (arg5 == NULL) SWIG_fail;
38407 temp5 = true;
38408 }
38409 }
38410 {
38411 PyThreadState* __tstate = wxPyBeginAllowThreads();
38412 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38413 wxPyEndAllowThreads(__tstate);
38414 if (PyErr_Occurred()) SWIG_fail;
38415 }
38416 {
38417 resultobj = wxPyMake_wxObject(result, (bool)0);
38418 }
38419 {
38420 if (temp3)
38421 delete arg3;
38422 }
38423 {
38424 if (temp5)
38425 delete arg5;
38426 }
38427 return resultobj;
38428 fail:
38429 {
38430 if (temp3)
38431 delete arg3;
38432 }
38433 {
38434 if (temp5)
38435 delete arg5;
38436 }
38437 return NULL;
38438 }
38439
38440
38441 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38442 PyObject *resultobj = 0;
38443 wxMenu *arg1 = (wxMenu *) 0 ;
38444 wxMenu *arg2 = (wxMenu *) 0 ;
38445 wxString *arg3 = 0 ;
38446 wxString const &arg4_defvalue = wxPyEmptyString ;
38447 wxString *arg4 = (wxString *) &arg4_defvalue ;
38448 wxMenuItem *result = 0 ;
38449 void *argp1 = 0 ;
38450 int res1 = 0 ;
38451 void *argp2 = 0 ;
38452 int res2 = 0 ;
38453 bool temp3 = false ;
38454 bool temp4 = false ;
38455 PyObject * obj0 = 0 ;
38456 PyObject * obj1 = 0 ;
38457 PyObject * obj2 = 0 ;
38458 PyObject * obj3 = 0 ;
38459 char * kwnames[] = {
38460 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38461 };
38462
38463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38465 if (!SWIG_IsOK(res1)) {
38466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38467 }
38468 arg1 = reinterpret_cast< wxMenu * >(argp1);
38469 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38470 if (!SWIG_IsOK(res2)) {
38471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38472 }
38473 arg2 = reinterpret_cast< wxMenu * >(argp2);
38474 {
38475 arg3 = wxString_in_helper(obj2);
38476 if (arg3 == NULL) SWIG_fail;
38477 temp3 = true;
38478 }
38479 if (obj3) {
38480 {
38481 arg4 = wxString_in_helper(obj3);
38482 if (arg4 == NULL) SWIG_fail;
38483 temp4 = true;
38484 }
38485 }
38486 {
38487 PyThreadState* __tstate = wxPyBeginAllowThreads();
38488 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38489 wxPyEndAllowThreads(__tstate);
38490 if (PyErr_Occurred()) SWIG_fail;
38491 }
38492 {
38493 resultobj = wxPyMake_wxObject(result, (bool)0);
38494 }
38495 {
38496 if (temp3)
38497 delete arg3;
38498 }
38499 {
38500 if (temp4)
38501 delete arg4;
38502 }
38503 return resultobj;
38504 fail:
38505 {
38506 if (temp3)
38507 delete arg3;
38508 }
38509 {
38510 if (temp4)
38511 delete arg4;
38512 }
38513 return NULL;
38514 }
38515
38516
38517 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38518 PyObject *resultobj = 0;
38519 wxMenu *arg1 = (wxMenu *) 0 ;
38520 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38521 wxMenuItem *result = 0 ;
38522 void *argp1 = 0 ;
38523 int res1 = 0 ;
38524 int res2 = 0 ;
38525 PyObject * obj0 = 0 ;
38526 PyObject * obj1 = 0 ;
38527 char * kwnames[] = {
38528 (char *) "self",(char *) "item", NULL
38529 };
38530
38531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38533 if (!SWIG_IsOK(res1)) {
38534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38535 }
38536 arg1 = reinterpret_cast< wxMenu * >(argp1);
38537 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38538 if (!SWIG_IsOK(res2)) {
38539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38540 }
38541 {
38542 PyThreadState* __tstate = wxPyBeginAllowThreads();
38543 result = (wxMenuItem *)(arg1)->Append(arg2);
38544 wxPyEndAllowThreads(__tstate);
38545 if (PyErr_Occurred()) SWIG_fail;
38546 }
38547 {
38548 resultobj = wxPyMake_wxObject(result, (bool)0);
38549 }
38550 return resultobj;
38551 fail:
38552 return NULL;
38553 }
38554
38555
38556 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38557 PyObject *resultobj = 0;
38558 wxMenu *arg1 = (wxMenu *) 0 ;
38559 size_t arg2 ;
38560 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38561 wxMenuItem *result = 0 ;
38562 void *argp1 = 0 ;
38563 int res1 = 0 ;
38564 size_t val2 ;
38565 int ecode2 = 0 ;
38566 int res3 = 0 ;
38567 PyObject * obj0 = 0 ;
38568 PyObject * obj1 = 0 ;
38569 PyObject * obj2 = 0 ;
38570 char * kwnames[] = {
38571 (char *) "self",(char *) "pos",(char *) "item", NULL
38572 };
38573
38574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38576 if (!SWIG_IsOK(res1)) {
38577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38578 }
38579 arg1 = reinterpret_cast< wxMenu * >(argp1);
38580 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38581 if (!SWIG_IsOK(ecode2)) {
38582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38583 }
38584 arg2 = static_cast< size_t >(val2);
38585 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38586 if (!SWIG_IsOK(res3)) {
38587 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38588 }
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38592 wxPyEndAllowThreads(__tstate);
38593 if (PyErr_Occurred()) SWIG_fail;
38594 }
38595 {
38596 resultobj = wxPyMake_wxObject(result, (bool)0);
38597 }
38598 return resultobj;
38599 fail:
38600 return NULL;
38601 }
38602
38603
38604 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38605 PyObject *resultobj = 0;
38606 wxMenu *arg1 = (wxMenu *) 0 ;
38607 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38608 wxMenuItem *result = 0 ;
38609 void *argp1 = 0 ;
38610 int res1 = 0 ;
38611 int res2 = 0 ;
38612 PyObject * obj0 = 0 ;
38613 PyObject * obj1 = 0 ;
38614 char * kwnames[] = {
38615 (char *) "self",(char *) "item", NULL
38616 };
38617
38618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38620 if (!SWIG_IsOK(res1)) {
38621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38622 }
38623 arg1 = reinterpret_cast< wxMenu * >(argp1);
38624 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38625 if (!SWIG_IsOK(res2)) {
38626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38627 }
38628 {
38629 PyThreadState* __tstate = wxPyBeginAllowThreads();
38630 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38631 wxPyEndAllowThreads(__tstate);
38632 if (PyErr_Occurred()) SWIG_fail;
38633 }
38634 {
38635 resultobj = wxPyMake_wxObject(result, (bool)0);
38636 }
38637 return resultobj;
38638 fail:
38639 return NULL;
38640 }
38641
38642
38643 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38644 PyObject *resultobj = 0;
38645 wxMenu *arg1 = (wxMenu *) 0 ;
38646 void *argp1 = 0 ;
38647 int res1 = 0 ;
38648 PyObject *swig_obj[1] ;
38649
38650 if (!args) SWIG_fail;
38651 swig_obj[0] = args;
38652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38653 if (!SWIG_IsOK(res1)) {
38654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38655 }
38656 arg1 = reinterpret_cast< wxMenu * >(argp1);
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 (arg1)->Break();
38660 wxPyEndAllowThreads(__tstate);
38661 if (PyErr_Occurred()) SWIG_fail;
38662 }
38663 resultobj = SWIG_Py_Void();
38664 return resultobj;
38665 fail:
38666 return NULL;
38667 }
38668
38669
38670 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38671 PyObject *resultobj = 0;
38672 wxMenu *arg1 = (wxMenu *) 0 ;
38673 size_t arg2 ;
38674 int arg3 ;
38675 wxString *arg4 = 0 ;
38676 wxString const &arg5_defvalue = wxPyEmptyString ;
38677 wxString *arg5 = (wxString *) &arg5_defvalue ;
38678 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38679 wxMenuItem *result = 0 ;
38680 void *argp1 = 0 ;
38681 int res1 = 0 ;
38682 size_t val2 ;
38683 int ecode2 = 0 ;
38684 int val3 ;
38685 int ecode3 = 0 ;
38686 bool temp4 = false ;
38687 bool temp5 = false ;
38688 int val6 ;
38689 int ecode6 = 0 ;
38690 PyObject * obj0 = 0 ;
38691 PyObject * obj1 = 0 ;
38692 PyObject * obj2 = 0 ;
38693 PyObject * obj3 = 0 ;
38694 PyObject * obj4 = 0 ;
38695 PyObject * obj5 = 0 ;
38696 char * kwnames[] = {
38697 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38698 };
38699
38700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38702 if (!SWIG_IsOK(res1)) {
38703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38704 }
38705 arg1 = reinterpret_cast< wxMenu * >(argp1);
38706 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38707 if (!SWIG_IsOK(ecode2)) {
38708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38709 }
38710 arg2 = static_cast< size_t >(val2);
38711 ecode3 = SWIG_AsVal_int(obj2, &val3);
38712 if (!SWIG_IsOK(ecode3)) {
38713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38714 }
38715 arg3 = static_cast< int >(val3);
38716 {
38717 arg4 = wxString_in_helper(obj3);
38718 if (arg4 == NULL) SWIG_fail;
38719 temp4 = true;
38720 }
38721 if (obj4) {
38722 {
38723 arg5 = wxString_in_helper(obj4);
38724 if (arg5 == NULL) SWIG_fail;
38725 temp5 = true;
38726 }
38727 }
38728 if (obj5) {
38729 ecode6 = SWIG_AsVal_int(obj5, &val6);
38730 if (!SWIG_IsOK(ecode6)) {
38731 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38732 }
38733 arg6 = static_cast< wxItemKind >(val6);
38734 }
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38738 wxPyEndAllowThreads(__tstate);
38739 if (PyErr_Occurred()) SWIG_fail;
38740 }
38741 {
38742 resultobj = wxPyMake_wxObject(result, (bool)0);
38743 }
38744 {
38745 if (temp4)
38746 delete arg4;
38747 }
38748 {
38749 if (temp5)
38750 delete arg5;
38751 }
38752 return resultobj;
38753 fail:
38754 {
38755 if (temp4)
38756 delete arg4;
38757 }
38758 {
38759 if (temp5)
38760 delete arg5;
38761 }
38762 return NULL;
38763 }
38764
38765
38766 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38767 PyObject *resultobj = 0;
38768 wxMenu *arg1 = (wxMenu *) 0 ;
38769 size_t arg2 ;
38770 wxMenuItem *result = 0 ;
38771 void *argp1 = 0 ;
38772 int res1 = 0 ;
38773 size_t val2 ;
38774 int ecode2 = 0 ;
38775 PyObject * obj0 = 0 ;
38776 PyObject * obj1 = 0 ;
38777 char * kwnames[] = {
38778 (char *) "self",(char *) "pos", NULL
38779 };
38780
38781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38783 if (!SWIG_IsOK(res1)) {
38784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38785 }
38786 arg1 = reinterpret_cast< wxMenu * >(argp1);
38787 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38788 if (!SWIG_IsOK(ecode2)) {
38789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38790 }
38791 arg2 = static_cast< size_t >(val2);
38792 {
38793 PyThreadState* __tstate = wxPyBeginAllowThreads();
38794 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38795 wxPyEndAllowThreads(__tstate);
38796 if (PyErr_Occurred()) SWIG_fail;
38797 }
38798 {
38799 resultobj = wxPyMake_wxObject(result, (bool)0);
38800 }
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38808 PyObject *resultobj = 0;
38809 wxMenu *arg1 = (wxMenu *) 0 ;
38810 size_t arg2 ;
38811 int arg3 ;
38812 wxString *arg4 = 0 ;
38813 wxString const &arg5_defvalue = wxPyEmptyString ;
38814 wxString *arg5 = (wxString *) &arg5_defvalue ;
38815 wxMenuItem *result = 0 ;
38816 void *argp1 = 0 ;
38817 int res1 = 0 ;
38818 size_t val2 ;
38819 int ecode2 = 0 ;
38820 int val3 ;
38821 int ecode3 = 0 ;
38822 bool temp4 = false ;
38823 bool temp5 = false ;
38824 PyObject * obj0 = 0 ;
38825 PyObject * obj1 = 0 ;
38826 PyObject * obj2 = 0 ;
38827 PyObject * obj3 = 0 ;
38828 PyObject * obj4 = 0 ;
38829 char * kwnames[] = {
38830 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38831 };
38832
38833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38835 if (!SWIG_IsOK(res1)) {
38836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38837 }
38838 arg1 = reinterpret_cast< wxMenu * >(argp1);
38839 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38840 if (!SWIG_IsOK(ecode2)) {
38841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38842 }
38843 arg2 = static_cast< size_t >(val2);
38844 ecode3 = SWIG_AsVal_int(obj2, &val3);
38845 if (!SWIG_IsOK(ecode3)) {
38846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38847 }
38848 arg3 = static_cast< int >(val3);
38849 {
38850 arg4 = wxString_in_helper(obj3);
38851 if (arg4 == NULL) SWIG_fail;
38852 temp4 = true;
38853 }
38854 if (obj4) {
38855 {
38856 arg5 = wxString_in_helper(obj4);
38857 if (arg5 == NULL) SWIG_fail;
38858 temp5 = true;
38859 }
38860 }
38861 {
38862 PyThreadState* __tstate = wxPyBeginAllowThreads();
38863 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 {
38868 resultobj = wxPyMake_wxObject(result, (bool)0);
38869 }
38870 {
38871 if (temp4)
38872 delete arg4;
38873 }
38874 {
38875 if (temp5)
38876 delete arg5;
38877 }
38878 return resultobj;
38879 fail:
38880 {
38881 if (temp4)
38882 delete arg4;
38883 }
38884 {
38885 if (temp5)
38886 delete arg5;
38887 }
38888 return NULL;
38889 }
38890
38891
38892 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38893 PyObject *resultobj = 0;
38894 wxMenu *arg1 = (wxMenu *) 0 ;
38895 size_t arg2 ;
38896 int arg3 ;
38897 wxString *arg4 = 0 ;
38898 wxString const &arg5_defvalue = wxPyEmptyString ;
38899 wxString *arg5 = (wxString *) &arg5_defvalue ;
38900 wxMenuItem *result = 0 ;
38901 void *argp1 = 0 ;
38902 int res1 = 0 ;
38903 size_t val2 ;
38904 int ecode2 = 0 ;
38905 int val3 ;
38906 int ecode3 = 0 ;
38907 bool temp4 = false ;
38908 bool temp5 = false ;
38909 PyObject * obj0 = 0 ;
38910 PyObject * obj1 = 0 ;
38911 PyObject * obj2 = 0 ;
38912 PyObject * obj3 = 0 ;
38913 PyObject * obj4 = 0 ;
38914 char * kwnames[] = {
38915 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38916 };
38917
38918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38920 if (!SWIG_IsOK(res1)) {
38921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38922 }
38923 arg1 = reinterpret_cast< wxMenu * >(argp1);
38924 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38925 if (!SWIG_IsOK(ecode2)) {
38926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38927 }
38928 arg2 = static_cast< size_t >(val2);
38929 ecode3 = SWIG_AsVal_int(obj2, &val3);
38930 if (!SWIG_IsOK(ecode3)) {
38931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38932 }
38933 arg3 = static_cast< int >(val3);
38934 {
38935 arg4 = wxString_in_helper(obj3);
38936 if (arg4 == NULL) SWIG_fail;
38937 temp4 = true;
38938 }
38939 if (obj4) {
38940 {
38941 arg5 = wxString_in_helper(obj4);
38942 if (arg5 == NULL) SWIG_fail;
38943 temp5 = true;
38944 }
38945 }
38946 {
38947 PyThreadState* __tstate = wxPyBeginAllowThreads();
38948 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 {
38953 resultobj = wxPyMake_wxObject(result, (bool)0);
38954 }
38955 {
38956 if (temp4)
38957 delete arg4;
38958 }
38959 {
38960 if (temp5)
38961 delete arg5;
38962 }
38963 return resultobj;
38964 fail:
38965 {
38966 if (temp4)
38967 delete arg4;
38968 }
38969 {
38970 if (temp5)
38971 delete arg5;
38972 }
38973 return NULL;
38974 }
38975
38976
38977 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38978 PyObject *resultobj = 0;
38979 wxMenu *arg1 = (wxMenu *) 0 ;
38980 size_t arg2 ;
38981 int arg3 ;
38982 wxString *arg4 = 0 ;
38983 wxMenu *arg5 = (wxMenu *) 0 ;
38984 wxString const &arg6_defvalue = wxPyEmptyString ;
38985 wxString *arg6 = (wxString *) &arg6_defvalue ;
38986 wxMenuItem *result = 0 ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 size_t val2 ;
38990 int ecode2 = 0 ;
38991 int val3 ;
38992 int ecode3 = 0 ;
38993 bool temp4 = false ;
38994 void *argp5 = 0 ;
38995 int res5 = 0 ;
38996 bool temp6 = false ;
38997 PyObject * obj0 = 0 ;
38998 PyObject * obj1 = 0 ;
38999 PyObject * obj2 = 0 ;
39000 PyObject * obj3 = 0 ;
39001 PyObject * obj4 = 0 ;
39002 PyObject * obj5 = 0 ;
39003 char * kwnames[] = {
39004 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39005 };
39006
39007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39009 if (!SWIG_IsOK(res1)) {
39010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39011 }
39012 arg1 = reinterpret_cast< wxMenu * >(argp1);
39013 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39014 if (!SWIG_IsOK(ecode2)) {
39015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39016 }
39017 arg2 = static_cast< size_t >(val2);
39018 ecode3 = SWIG_AsVal_int(obj2, &val3);
39019 if (!SWIG_IsOK(ecode3)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39021 }
39022 arg3 = static_cast< int >(val3);
39023 {
39024 arg4 = wxString_in_helper(obj3);
39025 if (arg4 == NULL) SWIG_fail;
39026 temp4 = true;
39027 }
39028 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39029 if (!SWIG_IsOK(res5)) {
39030 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39031 }
39032 arg5 = reinterpret_cast< wxMenu * >(argp5);
39033 if (obj5) {
39034 {
39035 arg6 = wxString_in_helper(obj5);
39036 if (arg6 == NULL) SWIG_fail;
39037 temp6 = true;
39038 }
39039 }
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 {
39047 resultobj = wxPyMake_wxObject(result, (bool)0);
39048 }
39049 {
39050 if (temp4)
39051 delete arg4;
39052 }
39053 {
39054 if (temp6)
39055 delete arg6;
39056 }
39057 return resultobj;
39058 fail:
39059 {
39060 if (temp4)
39061 delete arg4;
39062 }
39063 {
39064 if (temp6)
39065 delete arg6;
39066 }
39067 return NULL;
39068 }
39069
39070
39071 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39072 PyObject *resultobj = 0;
39073 wxMenu *arg1 = (wxMenu *) 0 ;
39074 int arg2 ;
39075 wxString *arg3 = 0 ;
39076 wxString const &arg4_defvalue = wxPyEmptyString ;
39077 wxString *arg4 = (wxString *) &arg4_defvalue ;
39078 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39079 wxMenuItem *result = 0 ;
39080 void *argp1 = 0 ;
39081 int res1 = 0 ;
39082 int val2 ;
39083 int ecode2 = 0 ;
39084 bool temp3 = false ;
39085 bool temp4 = false ;
39086 int val5 ;
39087 int ecode5 = 0 ;
39088 PyObject * obj0 = 0 ;
39089 PyObject * obj1 = 0 ;
39090 PyObject * obj2 = 0 ;
39091 PyObject * obj3 = 0 ;
39092 PyObject * obj4 = 0 ;
39093 char * kwnames[] = {
39094 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39095 };
39096
39097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39099 if (!SWIG_IsOK(res1)) {
39100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39101 }
39102 arg1 = reinterpret_cast< wxMenu * >(argp1);
39103 ecode2 = SWIG_AsVal_int(obj1, &val2);
39104 if (!SWIG_IsOK(ecode2)) {
39105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39106 }
39107 arg2 = static_cast< int >(val2);
39108 {
39109 arg3 = wxString_in_helper(obj2);
39110 if (arg3 == NULL) SWIG_fail;
39111 temp3 = true;
39112 }
39113 if (obj3) {
39114 {
39115 arg4 = wxString_in_helper(obj3);
39116 if (arg4 == NULL) SWIG_fail;
39117 temp4 = true;
39118 }
39119 }
39120 if (obj4) {
39121 ecode5 = SWIG_AsVal_int(obj4, &val5);
39122 if (!SWIG_IsOK(ecode5)) {
39123 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39124 }
39125 arg5 = static_cast< wxItemKind >(val5);
39126 }
39127 {
39128 PyThreadState* __tstate = wxPyBeginAllowThreads();
39129 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39130 wxPyEndAllowThreads(__tstate);
39131 if (PyErr_Occurred()) SWIG_fail;
39132 }
39133 {
39134 resultobj = wxPyMake_wxObject(result, (bool)0);
39135 }
39136 {
39137 if (temp3)
39138 delete arg3;
39139 }
39140 {
39141 if (temp4)
39142 delete arg4;
39143 }
39144 return resultobj;
39145 fail:
39146 {
39147 if (temp3)
39148 delete arg3;
39149 }
39150 {
39151 if (temp4)
39152 delete arg4;
39153 }
39154 return NULL;
39155 }
39156
39157
39158 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39159 PyObject *resultobj = 0;
39160 wxMenu *arg1 = (wxMenu *) 0 ;
39161 wxMenuItem *result = 0 ;
39162 void *argp1 = 0 ;
39163 int res1 = 0 ;
39164 PyObject *swig_obj[1] ;
39165
39166 if (!args) SWIG_fail;
39167 swig_obj[0] = args;
39168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39169 if (!SWIG_IsOK(res1)) {
39170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39171 }
39172 arg1 = reinterpret_cast< wxMenu * >(argp1);
39173 {
39174 PyThreadState* __tstate = wxPyBeginAllowThreads();
39175 result = (wxMenuItem *)(arg1)->PrependSeparator();
39176 wxPyEndAllowThreads(__tstate);
39177 if (PyErr_Occurred()) SWIG_fail;
39178 }
39179 {
39180 resultobj = wxPyMake_wxObject(result, (bool)0);
39181 }
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj = 0;
39190 wxMenu *arg1 = (wxMenu *) 0 ;
39191 int arg2 ;
39192 wxString *arg3 = 0 ;
39193 wxString const &arg4_defvalue = wxPyEmptyString ;
39194 wxString *arg4 = (wxString *) &arg4_defvalue ;
39195 wxMenuItem *result = 0 ;
39196 void *argp1 = 0 ;
39197 int res1 = 0 ;
39198 int val2 ;
39199 int ecode2 = 0 ;
39200 bool temp3 = false ;
39201 bool temp4 = false ;
39202 PyObject * obj0 = 0 ;
39203 PyObject * obj1 = 0 ;
39204 PyObject * obj2 = 0 ;
39205 PyObject * obj3 = 0 ;
39206 char * kwnames[] = {
39207 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39208 };
39209
39210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39212 if (!SWIG_IsOK(res1)) {
39213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39214 }
39215 arg1 = reinterpret_cast< wxMenu * >(argp1);
39216 ecode2 = SWIG_AsVal_int(obj1, &val2);
39217 if (!SWIG_IsOK(ecode2)) {
39218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39219 }
39220 arg2 = static_cast< int >(val2);
39221 {
39222 arg3 = wxString_in_helper(obj2);
39223 if (arg3 == NULL) SWIG_fail;
39224 temp3 = true;
39225 }
39226 if (obj3) {
39227 {
39228 arg4 = wxString_in_helper(obj3);
39229 if (arg4 == NULL) SWIG_fail;
39230 temp4 = true;
39231 }
39232 }
39233 {
39234 PyThreadState* __tstate = wxPyBeginAllowThreads();
39235 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39236 wxPyEndAllowThreads(__tstate);
39237 if (PyErr_Occurred()) SWIG_fail;
39238 }
39239 {
39240 resultobj = wxPyMake_wxObject(result, (bool)0);
39241 }
39242 {
39243 if (temp3)
39244 delete arg3;
39245 }
39246 {
39247 if (temp4)
39248 delete arg4;
39249 }
39250 return resultobj;
39251 fail:
39252 {
39253 if (temp3)
39254 delete arg3;
39255 }
39256 {
39257 if (temp4)
39258 delete arg4;
39259 }
39260 return NULL;
39261 }
39262
39263
39264 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39265 PyObject *resultobj = 0;
39266 wxMenu *arg1 = (wxMenu *) 0 ;
39267 int arg2 ;
39268 wxString *arg3 = 0 ;
39269 wxString const &arg4_defvalue = wxPyEmptyString ;
39270 wxString *arg4 = (wxString *) &arg4_defvalue ;
39271 wxMenuItem *result = 0 ;
39272 void *argp1 = 0 ;
39273 int res1 = 0 ;
39274 int val2 ;
39275 int ecode2 = 0 ;
39276 bool temp3 = false ;
39277 bool temp4 = false ;
39278 PyObject * obj0 = 0 ;
39279 PyObject * obj1 = 0 ;
39280 PyObject * obj2 = 0 ;
39281 PyObject * obj3 = 0 ;
39282 char * kwnames[] = {
39283 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39284 };
39285
39286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39288 if (!SWIG_IsOK(res1)) {
39289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39290 }
39291 arg1 = reinterpret_cast< wxMenu * >(argp1);
39292 ecode2 = SWIG_AsVal_int(obj1, &val2);
39293 if (!SWIG_IsOK(ecode2)) {
39294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39295 }
39296 arg2 = static_cast< int >(val2);
39297 {
39298 arg3 = wxString_in_helper(obj2);
39299 if (arg3 == NULL) SWIG_fail;
39300 temp3 = true;
39301 }
39302 if (obj3) {
39303 {
39304 arg4 = wxString_in_helper(obj3);
39305 if (arg4 == NULL) SWIG_fail;
39306 temp4 = true;
39307 }
39308 }
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 {
39316 resultobj = wxPyMake_wxObject(result, (bool)0);
39317 }
39318 {
39319 if (temp3)
39320 delete arg3;
39321 }
39322 {
39323 if (temp4)
39324 delete arg4;
39325 }
39326 return resultobj;
39327 fail:
39328 {
39329 if (temp3)
39330 delete arg3;
39331 }
39332 {
39333 if (temp4)
39334 delete arg4;
39335 }
39336 return NULL;
39337 }
39338
39339
39340 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39341 PyObject *resultobj = 0;
39342 wxMenu *arg1 = (wxMenu *) 0 ;
39343 int arg2 ;
39344 wxString *arg3 = 0 ;
39345 wxMenu *arg4 = (wxMenu *) 0 ;
39346 wxString const &arg5_defvalue = wxPyEmptyString ;
39347 wxString *arg5 = (wxString *) &arg5_defvalue ;
39348 wxMenuItem *result = 0 ;
39349 void *argp1 = 0 ;
39350 int res1 = 0 ;
39351 int val2 ;
39352 int ecode2 = 0 ;
39353 bool temp3 = false ;
39354 void *argp4 = 0 ;
39355 int res4 = 0 ;
39356 bool temp5 = false ;
39357 PyObject * obj0 = 0 ;
39358 PyObject * obj1 = 0 ;
39359 PyObject * obj2 = 0 ;
39360 PyObject * obj3 = 0 ;
39361 PyObject * obj4 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39370 }
39371 arg1 = reinterpret_cast< wxMenu * >(argp1);
39372 ecode2 = SWIG_AsVal_int(obj1, &val2);
39373 if (!SWIG_IsOK(ecode2)) {
39374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39375 }
39376 arg2 = static_cast< int >(val2);
39377 {
39378 arg3 = wxString_in_helper(obj2);
39379 if (arg3 == NULL) SWIG_fail;
39380 temp3 = true;
39381 }
39382 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39383 if (!SWIG_IsOK(res4)) {
39384 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39385 }
39386 arg4 = reinterpret_cast< wxMenu * >(argp4);
39387 if (obj4) {
39388 {
39389 arg5 = wxString_in_helper(obj4);
39390 if (arg5 == NULL) SWIG_fail;
39391 temp5 = true;
39392 }
39393 }
39394 {
39395 PyThreadState* __tstate = wxPyBeginAllowThreads();
39396 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39397 wxPyEndAllowThreads(__tstate);
39398 if (PyErr_Occurred()) SWIG_fail;
39399 }
39400 {
39401 resultobj = wxPyMake_wxObject(result, (bool)0);
39402 }
39403 {
39404 if (temp3)
39405 delete arg3;
39406 }
39407 {
39408 if (temp5)
39409 delete arg5;
39410 }
39411 return resultobj;
39412 fail:
39413 {
39414 if (temp3)
39415 delete arg3;
39416 }
39417 {
39418 if (temp5)
39419 delete arg5;
39420 }
39421 return NULL;
39422 }
39423
39424
39425 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj = 0;
39427 wxMenu *arg1 = (wxMenu *) 0 ;
39428 int arg2 ;
39429 wxMenuItem *result = 0 ;
39430 void *argp1 = 0 ;
39431 int res1 = 0 ;
39432 int val2 ;
39433 int ecode2 = 0 ;
39434 PyObject * obj0 = 0 ;
39435 PyObject * obj1 = 0 ;
39436 char * kwnames[] = {
39437 (char *) "self",(char *) "id", NULL
39438 };
39439
39440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39442 if (!SWIG_IsOK(res1)) {
39443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39444 }
39445 arg1 = reinterpret_cast< wxMenu * >(argp1);
39446 ecode2 = SWIG_AsVal_int(obj1, &val2);
39447 if (!SWIG_IsOK(ecode2)) {
39448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39449 }
39450 arg2 = static_cast< int >(val2);
39451 {
39452 PyThreadState* __tstate = wxPyBeginAllowThreads();
39453 result = (wxMenuItem *)(arg1)->Remove(arg2);
39454 wxPyEndAllowThreads(__tstate);
39455 if (PyErr_Occurred()) SWIG_fail;
39456 }
39457 {
39458 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39459 }
39460 return resultobj;
39461 fail:
39462 return NULL;
39463 }
39464
39465
39466 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39467 PyObject *resultobj = 0;
39468 wxMenu *arg1 = (wxMenu *) 0 ;
39469 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39470 wxMenuItem *result = 0 ;
39471 void *argp1 = 0 ;
39472 int res1 = 0 ;
39473 void *argp2 = 0 ;
39474 int res2 = 0 ;
39475 PyObject * obj0 = 0 ;
39476 PyObject * obj1 = 0 ;
39477 char * kwnames[] = {
39478 (char *) "self",(char *) "item", NULL
39479 };
39480
39481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39483 if (!SWIG_IsOK(res1)) {
39484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39485 }
39486 arg1 = reinterpret_cast< wxMenu * >(argp1);
39487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39488 if (!SWIG_IsOK(res2)) {
39489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39490 }
39491 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39492 {
39493 PyThreadState* __tstate = wxPyBeginAllowThreads();
39494 result = (wxMenuItem *)(arg1)->Remove(arg2);
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 {
39499 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39500 }
39501 return resultobj;
39502 fail:
39503 return NULL;
39504 }
39505
39506
39507 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39508 PyObject *resultobj = 0;
39509 wxMenu *arg1 = (wxMenu *) 0 ;
39510 int arg2 ;
39511 bool result;
39512 void *argp1 = 0 ;
39513 int res1 = 0 ;
39514 int val2 ;
39515 int ecode2 = 0 ;
39516 PyObject * obj0 = 0 ;
39517 PyObject * obj1 = 0 ;
39518 char * kwnames[] = {
39519 (char *) "self",(char *) "id", NULL
39520 };
39521
39522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39524 if (!SWIG_IsOK(res1)) {
39525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39526 }
39527 arg1 = reinterpret_cast< wxMenu * >(argp1);
39528 ecode2 = SWIG_AsVal_int(obj1, &val2);
39529 if (!SWIG_IsOK(ecode2)) {
39530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39531 }
39532 arg2 = static_cast< int >(val2);
39533 {
39534 PyThreadState* __tstate = wxPyBeginAllowThreads();
39535 result = (bool)(arg1)->Delete(arg2);
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 {
39540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39541 }
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj = 0;
39550 wxMenu *arg1 = (wxMenu *) 0 ;
39551 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39552 bool result;
39553 void *argp1 = 0 ;
39554 int res1 = 0 ;
39555 void *argp2 = 0 ;
39556 int res2 = 0 ;
39557 PyObject * obj0 = 0 ;
39558 PyObject * obj1 = 0 ;
39559 char * kwnames[] = {
39560 (char *) "self",(char *) "item", NULL
39561 };
39562
39563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39565 if (!SWIG_IsOK(res1)) {
39566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39567 }
39568 arg1 = reinterpret_cast< wxMenu * >(argp1);
39569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39570 if (!SWIG_IsOK(res2)) {
39571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39572 }
39573 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39574 {
39575 PyThreadState* __tstate = wxPyBeginAllowThreads();
39576 result = (bool)(arg1)->Delete(arg2);
39577 wxPyEndAllowThreads(__tstate);
39578 if (PyErr_Occurred()) SWIG_fail;
39579 }
39580 {
39581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39582 }
39583 return resultobj;
39584 fail:
39585 return NULL;
39586 }
39587
39588
39589 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39590 PyObject *resultobj = 0;
39591 wxMenu *arg1 = (wxMenu *) 0 ;
39592 void *argp1 = 0 ;
39593 int res1 = 0 ;
39594 PyObject *swig_obj[1] ;
39595
39596 if (!args) SWIG_fail;
39597 swig_obj[0] = args;
39598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39599 if (!SWIG_IsOK(res1)) {
39600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39601 }
39602 arg1 = reinterpret_cast< wxMenu * >(argp1);
39603 {
39604 PyThreadState* __tstate = wxPyBeginAllowThreads();
39605 wxMenu_Destroy(arg1);
39606 wxPyEndAllowThreads(__tstate);
39607 if (PyErr_Occurred()) SWIG_fail;
39608 }
39609 resultobj = SWIG_Py_Void();
39610 return resultobj;
39611 fail:
39612 return NULL;
39613 }
39614
39615
39616 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39617 PyObject *resultobj = 0;
39618 wxMenu *arg1 = (wxMenu *) 0 ;
39619 int arg2 ;
39620 bool result;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 int val2 ;
39624 int ecode2 = 0 ;
39625 PyObject * obj0 = 0 ;
39626 PyObject * obj1 = 0 ;
39627 char * kwnames[] = {
39628 (char *) "self",(char *) "id", NULL
39629 };
39630
39631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39633 if (!SWIG_IsOK(res1)) {
39634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39635 }
39636 arg1 = reinterpret_cast< wxMenu * >(argp1);
39637 ecode2 = SWIG_AsVal_int(obj1, &val2);
39638 if (!SWIG_IsOK(ecode2)) {
39639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39640 }
39641 arg2 = static_cast< int >(val2);
39642 {
39643 PyThreadState* __tstate = wxPyBeginAllowThreads();
39644 result = (bool)(arg1)->Destroy(arg2);
39645 wxPyEndAllowThreads(__tstate);
39646 if (PyErr_Occurred()) SWIG_fail;
39647 }
39648 {
39649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39650 }
39651 return resultobj;
39652 fail:
39653 return NULL;
39654 }
39655
39656
39657 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39658 PyObject *resultobj = 0;
39659 wxMenu *arg1 = (wxMenu *) 0 ;
39660 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39661 bool result;
39662 void *argp1 = 0 ;
39663 int res1 = 0 ;
39664 void *argp2 = 0 ;
39665 int res2 = 0 ;
39666 PyObject * obj0 = 0 ;
39667 PyObject * obj1 = 0 ;
39668 char * kwnames[] = {
39669 (char *) "self",(char *) "item", NULL
39670 };
39671
39672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39676 }
39677 arg1 = reinterpret_cast< wxMenu * >(argp1);
39678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39679 if (!SWIG_IsOK(res2)) {
39680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39681 }
39682 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (bool)(arg1)->Destroy(arg2);
39686 wxPyEndAllowThreads(__tstate);
39687 if (PyErr_Occurred()) SWIG_fail;
39688 }
39689 {
39690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39691 }
39692 return resultobj;
39693 fail:
39694 return NULL;
39695 }
39696
39697
39698 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39699 PyObject *resultobj = 0;
39700 wxMenu *arg1 = (wxMenu *) 0 ;
39701 size_t result;
39702 void *argp1 = 0 ;
39703 int res1 = 0 ;
39704 PyObject *swig_obj[1] ;
39705
39706 if (!args) SWIG_fail;
39707 swig_obj[0] = args;
39708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39709 if (!SWIG_IsOK(res1)) {
39710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39711 }
39712 arg1 = reinterpret_cast< wxMenu * >(argp1);
39713 {
39714 PyThreadState* __tstate = wxPyBeginAllowThreads();
39715 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39716 wxPyEndAllowThreads(__tstate);
39717 if (PyErr_Occurred()) SWIG_fail;
39718 }
39719 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39720 return resultobj;
39721 fail:
39722 return NULL;
39723 }
39724
39725
39726 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39727 PyObject *resultobj = 0;
39728 wxMenu *arg1 = (wxMenu *) 0 ;
39729 PyObject *result = 0 ;
39730 void *argp1 = 0 ;
39731 int res1 = 0 ;
39732 PyObject *swig_obj[1] ;
39733
39734 if (!args) SWIG_fail;
39735 swig_obj[0] = args;
39736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39737 if (!SWIG_IsOK(res1)) {
39738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39739 }
39740 arg1 = reinterpret_cast< wxMenu * >(argp1);
39741 {
39742 PyThreadState* __tstate = wxPyBeginAllowThreads();
39743 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39744 wxPyEndAllowThreads(__tstate);
39745 if (PyErr_Occurred()) SWIG_fail;
39746 }
39747 resultobj = result;
39748 return resultobj;
39749 fail:
39750 return NULL;
39751 }
39752
39753
39754 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj = 0;
39756 wxMenu *arg1 = (wxMenu *) 0 ;
39757 wxString *arg2 = 0 ;
39758 int result;
39759 void *argp1 = 0 ;
39760 int res1 = 0 ;
39761 bool temp2 = false ;
39762 PyObject * obj0 = 0 ;
39763 PyObject * obj1 = 0 ;
39764 char * kwnames[] = {
39765 (char *) "self",(char *) "item", NULL
39766 };
39767
39768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39770 if (!SWIG_IsOK(res1)) {
39771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39772 }
39773 arg1 = reinterpret_cast< wxMenu * >(argp1);
39774 {
39775 arg2 = wxString_in_helper(obj1);
39776 if (arg2 == NULL) SWIG_fail;
39777 temp2 = true;
39778 }
39779 {
39780 PyThreadState* __tstate = wxPyBeginAllowThreads();
39781 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39782 wxPyEndAllowThreads(__tstate);
39783 if (PyErr_Occurred()) SWIG_fail;
39784 }
39785 resultobj = SWIG_From_int(static_cast< int >(result));
39786 {
39787 if (temp2)
39788 delete arg2;
39789 }
39790 return resultobj;
39791 fail:
39792 {
39793 if (temp2)
39794 delete arg2;
39795 }
39796 return NULL;
39797 }
39798
39799
39800 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39801 PyObject *resultobj = 0;
39802 wxMenu *arg1 = (wxMenu *) 0 ;
39803 int arg2 ;
39804 wxMenuItem *result = 0 ;
39805 void *argp1 = 0 ;
39806 int res1 = 0 ;
39807 int val2 ;
39808 int ecode2 = 0 ;
39809 PyObject * obj0 = 0 ;
39810 PyObject * obj1 = 0 ;
39811 char * kwnames[] = {
39812 (char *) "self",(char *) "id", NULL
39813 };
39814
39815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39817 if (!SWIG_IsOK(res1)) {
39818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39819 }
39820 arg1 = reinterpret_cast< wxMenu * >(argp1);
39821 ecode2 = SWIG_AsVal_int(obj1, &val2);
39822 if (!SWIG_IsOK(ecode2)) {
39823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39824 }
39825 arg2 = static_cast< int >(val2);
39826 {
39827 PyThreadState* __tstate = wxPyBeginAllowThreads();
39828 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39829 wxPyEndAllowThreads(__tstate);
39830 if (PyErr_Occurred()) SWIG_fail;
39831 }
39832 {
39833 resultobj = wxPyMake_wxObject(result, (bool)0);
39834 }
39835 return resultobj;
39836 fail:
39837 return NULL;
39838 }
39839
39840
39841 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39842 PyObject *resultobj = 0;
39843 wxMenu *arg1 = (wxMenu *) 0 ;
39844 size_t arg2 ;
39845 wxMenuItem *result = 0 ;
39846 void *argp1 = 0 ;
39847 int res1 = 0 ;
39848 size_t val2 ;
39849 int ecode2 = 0 ;
39850 PyObject * obj0 = 0 ;
39851 PyObject * obj1 = 0 ;
39852 char * kwnames[] = {
39853 (char *) "self",(char *) "position", NULL
39854 };
39855
39856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39858 if (!SWIG_IsOK(res1)) {
39859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39860 }
39861 arg1 = reinterpret_cast< wxMenu * >(argp1);
39862 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39863 if (!SWIG_IsOK(ecode2)) {
39864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39865 }
39866 arg2 = static_cast< size_t >(val2);
39867 {
39868 PyThreadState* __tstate = wxPyBeginAllowThreads();
39869 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 {
39874 resultobj = wxPyMake_wxObject(result, (bool)0);
39875 }
39876 return resultobj;
39877 fail:
39878 return NULL;
39879 }
39880
39881
39882 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39883 PyObject *resultobj = 0;
39884 wxMenu *arg1 = (wxMenu *) 0 ;
39885 int arg2 ;
39886 bool arg3 ;
39887 void *argp1 = 0 ;
39888 int res1 = 0 ;
39889 int val2 ;
39890 int ecode2 = 0 ;
39891 bool val3 ;
39892 int ecode3 = 0 ;
39893 PyObject * obj0 = 0 ;
39894 PyObject * obj1 = 0 ;
39895 PyObject * obj2 = 0 ;
39896 char * kwnames[] = {
39897 (char *) "self",(char *) "id",(char *) "enable", NULL
39898 };
39899
39900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39902 if (!SWIG_IsOK(res1)) {
39903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39904 }
39905 arg1 = reinterpret_cast< wxMenu * >(argp1);
39906 ecode2 = SWIG_AsVal_int(obj1, &val2);
39907 if (!SWIG_IsOK(ecode2)) {
39908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39909 }
39910 arg2 = static_cast< int >(val2);
39911 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39912 if (!SWIG_IsOK(ecode3)) {
39913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39914 }
39915 arg3 = static_cast< bool >(val3);
39916 {
39917 PyThreadState* __tstate = wxPyBeginAllowThreads();
39918 (arg1)->Enable(arg2,arg3);
39919 wxPyEndAllowThreads(__tstate);
39920 if (PyErr_Occurred()) SWIG_fail;
39921 }
39922 resultobj = SWIG_Py_Void();
39923 return resultobj;
39924 fail:
39925 return NULL;
39926 }
39927
39928
39929 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39930 PyObject *resultobj = 0;
39931 wxMenu *arg1 = (wxMenu *) 0 ;
39932 int arg2 ;
39933 bool result;
39934 void *argp1 = 0 ;
39935 int res1 = 0 ;
39936 int val2 ;
39937 int ecode2 = 0 ;
39938 PyObject * obj0 = 0 ;
39939 PyObject * obj1 = 0 ;
39940 char * kwnames[] = {
39941 (char *) "self",(char *) "id", NULL
39942 };
39943
39944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39946 if (!SWIG_IsOK(res1)) {
39947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39948 }
39949 arg1 = reinterpret_cast< wxMenu * >(argp1);
39950 ecode2 = SWIG_AsVal_int(obj1, &val2);
39951 if (!SWIG_IsOK(ecode2)) {
39952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39953 }
39954 arg2 = static_cast< int >(val2);
39955 {
39956 PyThreadState* __tstate = wxPyBeginAllowThreads();
39957 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 {
39962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39963 }
39964 return resultobj;
39965 fail:
39966 return NULL;
39967 }
39968
39969
39970 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39971 PyObject *resultobj = 0;
39972 wxMenu *arg1 = (wxMenu *) 0 ;
39973 int arg2 ;
39974 bool arg3 ;
39975 void *argp1 = 0 ;
39976 int res1 = 0 ;
39977 int val2 ;
39978 int ecode2 = 0 ;
39979 bool val3 ;
39980 int ecode3 = 0 ;
39981 PyObject * obj0 = 0 ;
39982 PyObject * obj1 = 0 ;
39983 PyObject * obj2 = 0 ;
39984 char * kwnames[] = {
39985 (char *) "self",(char *) "id",(char *) "check", NULL
39986 };
39987
39988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39990 if (!SWIG_IsOK(res1)) {
39991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39992 }
39993 arg1 = reinterpret_cast< wxMenu * >(argp1);
39994 ecode2 = SWIG_AsVal_int(obj1, &val2);
39995 if (!SWIG_IsOK(ecode2)) {
39996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39997 }
39998 arg2 = static_cast< int >(val2);
39999 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40000 if (!SWIG_IsOK(ecode3)) {
40001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40002 }
40003 arg3 = static_cast< bool >(val3);
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 (arg1)->Check(arg2,arg3);
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 resultobj = SWIG_Py_Void();
40011 return resultobj;
40012 fail:
40013 return NULL;
40014 }
40015
40016
40017 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40018 PyObject *resultobj = 0;
40019 wxMenu *arg1 = (wxMenu *) 0 ;
40020 int arg2 ;
40021 bool result;
40022 void *argp1 = 0 ;
40023 int res1 = 0 ;
40024 int val2 ;
40025 int ecode2 = 0 ;
40026 PyObject * obj0 = 0 ;
40027 PyObject * obj1 = 0 ;
40028 char * kwnames[] = {
40029 (char *) "self",(char *) "id", NULL
40030 };
40031
40032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40034 if (!SWIG_IsOK(res1)) {
40035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40036 }
40037 arg1 = reinterpret_cast< wxMenu * >(argp1);
40038 ecode2 = SWIG_AsVal_int(obj1, &val2);
40039 if (!SWIG_IsOK(ecode2)) {
40040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40041 }
40042 arg2 = static_cast< int >(val2);
40043 {
40044 PyThreadState* __tstate = wxPyBeginAllowThreads();
40045 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 {
40050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40051 }
40052 return resultobj;
40053 fail:
40054 return NULL;
40055 }
40056
40057
40058 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40059 PyObject *resultobj = 0;
40060 wxMenu *arg1 = (wxMenu *) 0 ;
40061 int arg2 ;
40062 wxString *arg3 = 0 ;
40063 void *argp1 = 0 ;
40064 int res1 = 0 ;
40065 int val2 ;
40066 int ecode2 = 0 ;
40067 bool temp3 = false ;
40068 PyObject * obj0 = 0 ;
40069 PyObject * obj1 = 0 ;
40070 PyObject * obj2 = 0 ;
40071 char * kwnames[] = {
40072 (char *) "self",(char *) "id",(char *) "label", NULL
40073 };
40074
40075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) 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_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
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_SetLabel" "', expected argument " "2"" of type '" "int""'");
40084 }
40085 arg2 = static_cast< int >(val2);
40086 {
40087 arg3 = wxString_in_helper(obj2);
40088 if (arg3 == NULL) SWIG_fail;
40089 temp3 = true;
40090 }
40091 {
40092 PyThreadState* __tstate = wxPyBeginAllowThreads();
40093 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40094 wxPyEndAllowThreads(__tstate);
40095 if (PyErr_Occurred()) SWIG_fail;
40096 }
40097 resultobj = SWIG_Py_Void();
40098 {
40099 if (temp3)
40100 delete arg3;
40101 }
40102 return resultobj;
40103 fail:
40104 {
40105 if (temp3)
40106 delete arg3;
40107 }
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = 0;
40114 wxMenu *arg1 = (wxMenu *) 0 ;
40115 int arg2 ;
40116 wxString result;
40117 void *argp1 = 0 ;
40118 int res1 = 0 ;
40119 int val2 ;
40120 int ecode2 = 0 ;
40121 PyObject * obj0 = 0 ;
40122 PyObject * obj1 = 0 ;
40123 char * kwnames[] = {
40124 (char *) "self",(char *) "id", NULL
40125 };
40126
40127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40129 if (!SWIG_IsOK(res1)) {
40130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40131 }
40132 arg1 = reinterpret_cast< wxMenu * >(argp1);
40133 ecode2 = SWIG_AsVal_int(obj1, &val2);
40134 if (!SWIG_IsOK(ecode2)) {
40135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40136 }
40137 arg2 = static_cast< int >(val2);
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40141 wxPyEndAllowThreads(__tstate);
40142 if (PyErr_Occurred()) SWIG_fail;
40143 }
40144 {
40145 #if wxUSE_UNICODE
40146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40147 #else
40148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40149 #endif
40150 }
40151 return resultobj;
40152 fail:
40153 return NULL;
40154 }
40155
40156
40157 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40158 PyObject *resultobj = 0;
40159 wxMenu *arg1 = (wxMenu *) 0 ;
40160 int arg2 ;
40161 wxString *arg3 = 0 ;
40162 void *argp1 = 0 ;
40163 int res1 = 0 ;
40164 int val2 ;
40165 int ecode2 = 0 ;
40166 bool temp3 = false ;
40167 PyObject * obj0 = 0 ;
40168 PyObject * obj1 = 0 ;
40169 PyObject * obj2 = 0 ;
40170 char * kwnames[] = {
40171 (char *) "self",(char *) "id",(char *) "helpString", NULL
40172 };
40173
40174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40176 if (!SWIG_IsOK(res1)) {
40177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40178 }
40179 arg1 = reinterpret_cast< wxMenu * >(argp1);
40180 ecode2 = SWIG_AsVal_int(obj1, &val2);
40181 if (!SWIG_IsOK(ecode2)) {
40182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40183 }
40184 arg2 = static_cast< int >(val2);
40185 {
40186 arg3 = wxString_in_helper(obj2);
40187 if (arg3 == NULL) SWIG_fail;
40188 temp3 = true;
40189 }
40190 {
40191 PyThreadState* __tstate = wxPyBeginAllowThreads();
40192 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 resultobj = SWIG_Py_Void();
40197 {
40198 if (temp3)
40199 delete arg3;
40200 }
40201 return resultobj;
40202 fail:
40203 {
40204 if (temp3)
40205 delete arg3;
40206 }
40207 return NULL;
40208 }
40209
40210
40211 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40212 PyObject *resultobj = 0;
40213 wxMenu *arg1 = (wxMenu *) 0 ;
40214 int arg2 ;
40215 wxString result;
40216 void *argp1 = 0 ;
40217 int res1 = 0 ;
40218 int val2 ;
40219 int ecode2 = 0 ;
40220 PyObject * obj0 = 0 ;
40221 PyObject * obj1 = 0 ;
40222 char * kwnames[] = {
40223 (char *) "self",(char *) "id", NULL
40224 };
40225
40226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40228 if (!SWIG_IsOK(res1)) {
40229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40230 }
40231 arg1 = reinterpret_cast< wxMenu * >(argp1);
40232 ecode2 = SWIG_AsVal_int(obj1, &val2);
40233 if (!SWIG_IsOK(ecode2)) {
40234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40235 }
40236 arg2 = static_cast< int >(val2);
40237 {
40238 PyThreadState* __tstate = wxPyBeginAllowThreads();
40239 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 {
40244 #if wxUSE_UNICODE
40245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40246 #else
40247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40248 #endif
40249 }
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj = 0;
40258 wxMenu *arg1 = (wxMenu *) 0 ;
40259 wxString *arg2 = 0 ;
40260 void *argp1 = 0 ;
40261 int res1 = 0 ;
40262 bool temp2 = false ;
40263 PyObject * obj0 = 0 ;
40264 PyObject * obj1 = 0 ;
40265 char * kwnames[] = {
40266 (char *) "self",(char *) "title", NULL
40267 };
40268
40269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40271 if (!SWIG_IsOK(res1)) {
40272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40273 }
40274 arg1 = reinterpret_cast< wxMenu * >(argp1);
40275 {
40276 arg2 = wxString_in_helper(obj1);
40277 if (arg2 == NULL) SWIG_fail;
40278 temp2 = true;
40279 }
40280 {
40281 PyThreadState* __tstate = wxPyBeginAllowThreads();
40282 (arg1)->SetTitle((wxString const &)*arg2);
40283 wxPyEndAllowThreads(__tstate);
40284 if (PyErr_Occurred()) SWIG_fail;
40285 }
40286 resultobj = SWIG_Py_Void();
40287 {
40288 if (temp2)
40289 delete arg2;
40290 }
40291 return resultobj;
40292 fail:
40293 {
40294 if (temp2)
40295 delete arg2;
40296 }
40297 return NULL;
40298 }
40299
40300
40301 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40302 PyObject *resultobj = 0;
40303 wxMenu *arg1 = (wxMenu *) 0 ;
40304 wxString result;
40305 void *argp1 = 0 ;
40306 int res1 = 0 ;
40307 PyObject *swig_obj[1] ;
40308
40309 if (!args) SWIG_fail;
40310 swig_obj[0] = args;
40311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40312 if (!SWIG_IsOK(res1)) {
40313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40314 }
40315 arg1 = reinterpret_cast< wxMenu * >(argp1);
40316 {
40317 PyThreadState* __tstate = wxPyBeginAllowThreads();
40318 result = ((wxMenu const *)arg1)->GetTitle();
40319 wxPyEndAllowThreads(__tstate);
40320 if (PyErr_Occurred()) SWIG_fail;
40321 }
40322 {
40323 #if wxUSE_UNICODE
40324 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40325 #else
40326 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40327 #endif
40328 }
40329 return resultobj;
40330 fail:
40331 return NULL;
40332 }
40333
40334
40335 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40336 PyObject *resultobj = 0;
40337 wxMenu *arg1 = (wxMenu *) 0 ;
40338 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40339 void *argp1 = 0 ;
40340 int res1 = 0 ;
40341 void *argp2 = 0 ;
40342 int res2 = 0 ;
40343 PyObject * obj0 = 0 ;
40344 PyObject * obj1 = 0 ;
40345 char * kwnames[] = {
40346 (char *) "self",(char *) "handler", NULL
40347 };
40348
40349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40351 if (!SWIG_IsOK(res1)) {
40352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40353 }
40354 arg1 = reinterpret_cast< wxMenu * >(argp1);
40355 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40356 if (!SWIG_IsOK(res2)) {
40357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40358 }
40359 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 (arg1)->SetEventHandler(arg2);
40363 wxPyEndAllowThreads(__tstate);
40364 if (PyErr_Occurred()) SWIG_fail;
40365 }
40366 resultobj = SWIG_Py_Void();
40367 return resultobj;
40368 fail:
40369 return NULL;
40370 }
40371
40372
40373 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40374 PyObject *resultobj = 0;
40375 wxMenu *arg1 = (wxMenu *) 0 ;
40376 wxEvtHandler *result = 0 ;
40377 void *argp1 = 0 ;
40378 int res1 = 0 ;
40379 PyObject *swig_obj[1] ;
40380
40381 if (!args) SWIG_fail;
40382 swig_obj[0] = args;
40383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40384 if (!SWIG_IsOK(res1)) {
40385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40386 }
40387 arg1 = reinterpret_cast< wxMenu * >(argp1);
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40391 wxPyEndAllowThreads(__tstate);
40392 if (PyErr_Occurred()) SWIG_fail;
40393 }
40394 {
40395 resultobj = wxPyMake_wxObject(result, 0);
40396 }
40397 return resultobj;
40398 fail:
40399 return NULL;
40400 }
40401
40402
40403 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40404 PyObject *resultobj = 0;
40405 wxMenu *arg1 = (wxMenu *) 0 ;
40406 wxWindow *arg2 = (wxWindow *) 0 ;
40407 void *argp1 = 0 ;
40408 int res1 = 0 ;
40409 void *argp2 = 0 ;
40410 int res2 = 0 ;
40411 PyObject * obj0 = 0 ;
40412 PyObject * obj1 = 0 ;
40413 char * kwnames[] = {
40414 (char *) "self",(char *) "win", NULL
40415 };
40416
40417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40421 }
40422 arg1 = reinterpret_cast< wxMenu * >(argp1);
40423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40424 if (!SWIG_IsOK(res2)) {
40425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40426 }
40427 arg2 = reinterpret_cast< wxWindow * >(argp2);
40428 {
40429 PyThreadState* __tstate = wxPyBeginAllowThreads();
40430 (arg1)->SetInvokingWindow(arg2);
40431 wxPyEndAllowThreads(__tstate);
40432 if (PyErr_Occurred()) SWIG_fail;
40433 }
40434 resultobj = SWIG_Py_Void();
40435 return resultobj;
40436 fail:
40437 return NULL;
40438 }
40439
40440
40441 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40442 PyObject *resultobj = 0;
40443 wxMenu *arg1 = (wxMenu *) 0 ;
40444 wxWindow *result = 0 ;
40445 void *argp1 = 0 ;
40446 int res1 = 0 ;
40447 PyObject *swig_obj[1] ;
40448
40449 if (!args) SWIG_fail;
40450 swig_obj[0] = args;
40451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40454 }
40455 arg1 = reinterpret_cast< wxMenu * >(argp1);
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40459 wxPyEndAllowThreads(__tstate);
40460 if (PyErr_Occurred()) SWIG_fail;
40461 }
40462 {
40463 resultobj = wxPyMake_wxObject(result, 0);
40464 }
40465 return resultobj;
40466 fail:
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 long result;
40475 void *argp1 = 0 ;
40476 int res1 = 0 ;
40477 PyObject *swig_obj[1] ;
40478
40479 if (!args) SWIG_fail;
40480 swig_obj[0] = args;
40481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40482 if (!SWIG_IsOK(res1)) {
40483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40484 }
40485 arg1 = reinterpret_cast< wxMenu * >(argp1);
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = (long)((wxMenu const *)arg1)->GetStyle();
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 resultobj = SWIG_From_long(static_cast< long >(result));
40493 return resultobj;
40494 fail:
40495 return NULL;
40496 }
40497
40498
40499 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40500 PyObject *resultobj = 0;
40501 wxMenu *arg1 = (wxMenu *) 0 ;
40502 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40503 void *argp1 = 0 ;
40504 int res1 = 0 ;
40505 void *argp2 = 0 ;
40506 int res2 = 0 ;
40507 PyObject * obj0 = 0 ;
40508 PyObject * obj1 = 0 ;
40509 char * kwnames[] = {
40510 (char *) "self",(char *) "source", NULL
40511 };
40512
40513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40515 if (!SWIG_IsOK(res1)) {
40516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40517 }
40518 arg1 = reinterpret_cast< wxMenu * >(argp1);
40519 if (obj1) {
40520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40521 if (!SWIG_IsOK(res2)) {
40522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40523 }
40524 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40525 }
40526 {
40527 PyThreadState* __tstate = wxPyBeginAllowThreads();
40528 (arg1)->UpdateUI(arg2);
40529 wxPyEndAllowThreads(__tstate);
40530 if (PyErr_Occurred()) SWIG_fail;
40531 }
40532 resultobj = SWIG_Py_Void();
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40540 PyObject *resultobj = 0;
40541 wxMenu *arg1 = (wxMenu *) 0 ;
40542 wxMenuBar *result = 0 ;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 PyObject *swig_obj[1] ;
40546
40547 if (!args) SWIG_fail;
40548 swig_obj[0] = args;
40549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40550 if (!SWIG_IsOK(res1)) {
40551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 {
40555 PyThreadState* __tstate = wxPyBeginAllowThreads();
40556 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40557 wxPyEndAllowThreads(__tstate);
40558 if (PyErr_Occurred()) SWIG_fail;
40559 }
40560 {
40561 resultobj = wxPyMake_wxObject(result, (bool)0);
40562 }
40563 return resultobj;
40564 fail:
40565 return NULL;
40566 }
40567
40568
40569 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40570 PyObject *resultobj = 0;
40571 wxMenu *arg1 = (wxMenu *) 0 ;
40572 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40573 void *argp1 = 0 ;
40574 int res1 = 0 ;
40575 void *argp2 = 0 ;
40576 int res2 = 0 ;
40577 PyObject * obj0 = 0 ;
40578 PyObject * obj1 = 0 ;
40579 char * kwnames[] = {
40580 (char *) "self",(char *) "menubar", NULL
40581 };
40582
40583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40585 if (!SWIG_IsOK(res1)) {
40586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40587 }
40588 arg1 = reinterpret_cast< wxMenu * >(argp1);
40589 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40590 if (!SWIG_IsOK(res2)) {
40591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40592 }
40593 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40594 {
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 (arg1)->Attach(arg2);
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 resultobj = SWIG_Py_Void();
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40608 PyObject *resultobj = 0;
40609 wxMenu *arg1 = (wxMenu *) 0 ;
40610 void *argp1 = 0 ;
40611 int res1 = 0 ;
40612 PyObject *swig_obj[1] ;
40613
40614 if (!args) SWIG_fail;
40615 swig_obj[0] = args;
40616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 (arg1)->Detach();
40624 wxPyEndAllowThreads(__tstate);
40625 if (PyErr_Occurred()) SWIG_fail;
40626 }
40627 resultobj = SWIG_Py_Void();
40628 return resultobj;
40629 fail:
40630 return NULL;
40631 }
40632
40633
40634 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40635 PyObject *resultobj = 0;
40636 wxMenu *arg1 = (wxMenu *) 0 ;
40637 bool result;
40638 void *argp1 = 0 ;
40639 int res1 = 0 ;
40640 PyObject *swig_obj[1] ;
40641
40642 if (!args) SWIG_fail;
40643 swig_obj[0] = args;
40644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40645 if (!SWIG_IsOK(res1)) {
40646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40647 }
40648 arg1 = reinterpret_cast< wxMenu * >(argp1);
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 result = (bool)((wxMenu const *)arg1)->IsAttached();
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 {
40656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40657 }
40658 return resultobj;
40659 fail:
40660 return NULL;
40661 }
40662
40663
40664 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40665 PyObject *resultobj = 0;
40666 wxMenu *arg1 = (wxMenu *) 0 ;
40667 wxMenu *arg2 = (wxMenu *) 0 ;
40668 void *argp1 = 0 ;
40669 int res1 = 0 ;
40670 void *argp2 = 0 ;
40671 int res2 = 0 ;
40672 PyObject * obj0 = 0 ;
40673 PyObject * obj1 = 0 ;
40674 char * kwnames[] = {
40675 (char *) "self",(char *) "parent", NULL
40676 };
40677
40678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40680 if (!SWIG_IsOK(res1)) {
40681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40682 }
40683 arg1 = reinterpret_cast< wxMenu * >(argp1);
40684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res2)) {
40686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40687 }
40688 arg2 = reinterpret_cast< wxMenu * >(argp2);
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 (arg1)->SetParent(arg2);
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 resultobj = SWIG_Py_Void();
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40703 PyObject *resultobj = 0;
40704 wxMenu *arg1 = (wxMenu *) 0 ;
40705 wxMenu *result = 0 ;
40706 void *argp1 = 0 ;
40707 int res1 = 0 ;
40708 PyObject *swig_obj[1] ;
40709
40710 if (!args) SWIG_fail;
40711 swig_obj[0] = args;
40712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40713 if (!SWIG_IsOK(res1)) {
40714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40715 }
40716 arg1 = reinterpret_cast< wxMenu * >(argp1);
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 {
40724 resultobj = wxPyMake_wxObject(result, 0);
40725 }
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40733 PyObject *obj;
40734 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40735 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40736 return SWIG_Py_Void();
40737 }
40738
40739 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40740 return SWIG_Python_InitShadowInstance(args);
40741 }
40742
40743 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40744 PyObject *resultobj = 0;
40745 long arg1 = (long) 0 ;
40746 wxMenuBar *result = 0 ;
40747 long val1 ;
40748 int ecode1 = 0 ;
40749 PyObject * obj0 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "style", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40755 if (obj0) {
40756 ecode1 = SWIG_AsVal_long(obj0, &val1);
40757 if (!SWIG_IsOK(ecode1)) {
40758 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40759 }
40760 arg1 = static_cast< long >(val1);
40761 }
40762 {
40763 if (!wxPyCheckForApp()) SWIG_fail;
40764 PyThreadState* __tstate = wxPyBeginAllowThreads();
40765 result = (wxMenuBar *)new wxMenuBar(arg1);
40766 wxPyEndAllowThreads(__tstate);
40767 if (PyErr_Occurred()) SWIG_fail;
40768 }
40769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40770 return resultobj;
40771 fail:
40772 return NULL;
40773 }
40774
40775
40776 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40777 PyObject *resultobj = 0;
40778 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40779 wxMenu *arg2 = (wxMenu *) 0 ;
40780 wxString *arg3 = 0 ;
40781 bool result;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 void *argp2 = 0 ;
40785 int res2 = 0 ;
40786 bool temp3 = false ;
40787 PyObject * obj0 = 0 ;
40788 PyObject * obj1 = 0 ;
40789 PyObject * obj2 = 0 ;
40790 char * kwnames[] = {
40791 (char *) "self",(char *) "menu",(char *) "title", NULL
40792 };
40793
40794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40796 if (!SWIG_IsOK(res1)) {
40797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40798 }
40799 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40800 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40801 if (!SWIG_IsOK(res2)) {
40802 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40803 }
40804 arg2 = reinterpret_cast< wxMenu * >(argp2);
40805 {
40806 arg3 = wxString_in_helper(obj2);
40807 if (arg3 == NULL) SWIG_fail;
40808 temp3 = true;
40809 }
40810 {
40811 PyThreadState* __tstate = wxPyBeginAllowThreads();
40812 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40813 wxPyEndAllowThreads(__tstate);
40814 if (PyErr_Occurred()) SWIG_fail;
40815 }
40816 {
40817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40818 }
40819 {
40820 if (temp3)
40821 delete arg3;
40822 }
40823 return resultobj;
40824 fail:
40825 {
40826 if (temp3)
40827 delete arg3;
40828 }
40829 return NULL;
40830 }
40831
40832
40833 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40834 PyObject *resultobj = 0;
40835 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40836 size_t arg2 ;
40837 wxMenu *arg3 = (wxMenu *) 0 ;
40838 wxString *arg4 = 0 ;
40839 bool result;
40840 void *argp1 = 0 ;
40841 int res1 = 0 ;
40842 size_t val2 ;
40843 int ecode2 = 0 ;
40844 void *argp3 = 0 ;
40845 int res3 = 0 ;
40846 bool temp4 = false ;
40847 PyObject * obj0 = 0 ;
40848 PyObject * obj1 = 0 ;
40849 PyObject * obj2 = 0 ;
40850 PyObject * obj3 = 0 ;
40851 char * kwnames[] = {
40852 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40853 };
40854
40855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40857 if (!SWIG_IsOK(res1)) {
40858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40859 }
40860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40861 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40862 if (!SWIG_IsOK(ecode2)) {
40863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40864 }
40865 arg2 = static_cast< size_t >(val2);
40866 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40867 if (!SWIG_IsOK(res3)) {
40868 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40869 }
40870 arg3 = reinterpret_cast< wxMenu * >(argp3);
40871 {
40872 arg4 = wxString_in_helper(obj3);
40873 if (arg4 == NULL) SWIG_fail;
40874 temp4 = true;
40875 }
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40879 wxPyEndAllowThreads(__tstate);
40880 if (PyErr_Occurred()) SWIG_fail;
40881 }
40882 {
40883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40884 }
40885 {
40886 if (temp4)
40887 delete arg4;
40888 }
40889 return resultobj;
40890 fail:
40891 {
40892 if (temp4)
40893 delete arg4;
40894 }
40895 return NULL;
40896 }
40897
40898
40899 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40900 PyObject *resultobj = 0;
40901 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40902 size_t result;
40903 void *argp1 = 0 ;
40904 int res1 = 0 ;
40905 PyObject *swig_obj[1] ;
40906
40907 if (!args) SWIG_fail;
40908 swig_obj[0] = args;
40909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40912 }
40913 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40914 {
40915 PyThreadState* __tstate = wxPyBeginAllowThreads();
40916 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40917 wxPyEndAllowThreads(__tstate);
40918 if (PyErr_Occurred()) SWIG_fail;
40919 }
40920 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40921 return resultobj;
40922 fail:
40923 return NULL;
40924 }
40925
40926
40927 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40928 PyObject *resultobj = 0;
40929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40930 size_t arg2 ;
40931 wxMenu *result = 0 ;
40932 void *argp1 = 0 ;
40933 int res1 = 0 ;
40934 size_t val2 ;
40935 int ecode2 = 0 ;
40936 PyObject * obj0 = 0 ;
40937 PyObject * obj1 = 0 ;
40938 char * kwnames[] = {
40939 (char *) "self",(char *) "pos", NULL
40940 };
40941
40942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40944 if (!SWIG_IsOK(res1)) {
40945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40946 }
40947 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40948 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40949 if (!SWIG_IsOK(ecode2)) {
40950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40951 }
40952 arg2 = static_cast< size_t >(val2);
40953 {
40954 PyThreadState* __tstate = wxPyBeginAllowThreads();
40955 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 {
40960 resultobj = wxPyMake_wxObject(result, 0);
40961 }
40962 return resultobj;
40963 fail:
40964 return NULL;
40965 }
40966
40967
40968 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40969 PyObject *resultobj = 0;
40970 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40971 size_t arg2 ;
40972 wxMenu *arg3 = (wxMenu *) 0 ;
40973 wxString *arg4 = 0 ;
40974 wxMenu *result = 0 ;
40975 void *argp1 = 0 ;
40976 int res1 = 0 ;
40977 size_t val2 ;
40978 int ecode2 = 0 ;
40979 void *argp3 = 0 ;
40980 int res3 = 0 ;
40981 bool temp4 = false ;
40982 PyObject * obj0 = 0 ;
40983 PyObject * obj1 = 0 ;
40984 PyObject * obj2 = 0 ;
40985 PyObject * obj3 = 0 ;
40986 char * kwnames[] = {
40987 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40988 };
40989
40990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40992 if (!SWIG_IsOK(res1)) {
40993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40994 }
40995 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40996 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40997 if (!SWIG_IsOK(ecode2)) {
40998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40999 }
41000 arg2 = static_cast< size_t >(val2);
41001 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41002 if (!SWIG_IsOK(res3)) {
41003 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41004 }
41005 arg3 = reinterpret_cast< wxMenu * >(argp3);
41006 {
41007 arg4 = wxString_in_helper(obj3);
41008 if (arg4 == NULL) SWIG_fail;
41009 temp4 = true;
41010 }
41011 {
41012 PyThreadState* __tstate = wxPyBeginAllowThreads();
41013 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41014 wxPyEndAllowThreads(__tstate);
41015 if (PyErr_Occurred()) SWIG_fail;
41016 }
41017 {
41018 resultobj = wxPyMake_wxObject(result, 0);
41019 }
41020 {
41021 if (temp4)
41022 delete arg4;
41023 }
41024 return resultobj;
41025 fail:
41026 {
41027 if (temp4)
41028 delete arg4;
41029 }
41030 return NULL;
41031 }
41032
41033
41034 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41035 PyObject *resultobj = 0;
41036 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41037 size_t arg2 ;
41038 wxMenu *result = 0 ;
41039 void *argp1 = 0 ;
41040 int res1 = 0 ;
41041 size_t val2 ;
41042 int ecode2 = 0 ;
41043 PyObject * obj0 = 0 ;
41044 PyObject * obj1 = 0 ;
41045 char * kwnames[] = {
41046 (char *) "self",(char *) "pos", NULL
41047 };
41048
41049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41051 if (!SWIG_IsOK(res1)) {
41052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41053 }
41054 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41055 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41056 if (!SWIG_IsOK(ecode2)) {
41057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41058 }
41059 arg2 = static_cast< size_t >(val2);
41060 {
41061 PyThreadState* __tstate = wxPyBeginAllowThreads();
41062 result = (wxMenu *)(arg1)->Remove(arg2);
41063 wxPyEndAllowThreads(__tstate);
41064 if (PyErr_Occurred()) SWIG_fail;
41065 }
41066 {
41067 resultobj = wxPyMake_wxObject(result, 0);
41068 }
41069 return resultobj;
41070 fail:
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj = 0;
41077 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41078 size_t arg2 ;
41079 bool arg3 ;
41080 void *argp1 = 0 ;
41081 int res1 = 0 ;
41082 size_t val2 ;
41083 int ecode2 = 0 ;
41084 bool val3 ;
41085 int ecode3 = 0 ;
41086 PyObject * obj0 = 0 ;
41087 PyObject * obj1 = 0 ;
41088 PyObject * obj2 = 0 ;
41089 char * kwnames[] = {
41090 (char *) "self",(char *) "pos",(char *) "enable", NULL
41091 };
41092
41093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41095 if (!SWIG_IsOK(res1)) {
41096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41097 }
41098 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41099 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41100 if (!SWIG_IsOK(ecode2)) {
41101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41102 }
41103 arg2 = static_cast< size_t >(val2);
41104 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41105 if (!SWIG_IsOK(ecode3)) {
41106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41107 }
41108 arg3 = static_cast< bool >(val3);
41109 {
41110 PyThreadState* __tstate = wxPyBeginAllowThreads();
41111 (arg1)->EnableTop(arg2,arg3);
41112 wxPyEndAllowThreads(__tstate);
41113 if (PyErr_Occurred()) SWIG_fail;
41114 }
41115 resultobj = SWIG_Py_Void();
41116 return resultobj;
41117 fail:
41118 return NULL;
41119 }
41120
41121
41122 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41123 PyObject *resultobj = 0;
41124 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41125 size_t arg2 ;
41126 bool result;
41127 void *argp1 = 0 ;
41128 int res1 = 0 ;
41129 size_t val2 ;
41130 int ecode2 = 0 ;
41131 PyObject * obj0 = 0 ;
41132 PyObject * obj1 = 0 ;
41133 char * kwnames[] = {
41134 (char *) "self",(char *) "pos", NULL
41135 };
41136
41137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41139 if (!SWIG_IsOK(res1)) {
41140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41141 }
41142 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41143 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41144 if (!SWIG_IsOK(ecode2)) {
41145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41146 }
41147 arg2 = static_cast< size_t >(val2);
41148 {
41149 PyThreadState* __tstate = wxPyBeginAllowThreads();
41150 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 {
41155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41156 }
41157 return resultobj;
41158 fail:
41159 return NULL;
41160 }
41161
41162
41163 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41164 PyObject *resultobj = 0;
41165 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41166 size_t arg2 ;
41167 wxString *arg3 = 0 ;
41168 void *argp1 = 0 ;
41169 int res1 = 0 ;
41170 size_t val2 ;
41171 int ecode2 = 0 ;
41172 bool temp3 = false ;
41173 PyObject * obj0 = 0 ;
41174 PyObject * obj1 = 0 ;
41175 PyObject * obj2 = 0 ;
41176 char * kwnames[] = {
41177 (char *) "self",(char *) "pos",(char *) "label", NULL
41178 };
41179
41180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41182 if (!SWIG_IsOK(res1)) {
41183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41184 }
41185 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41186 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41187 if (!SWIG_IsOK(ecode2)) {
41188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41189 }
41190 arg2 = static_cast< size_t >(val2);
41191 {
41192 arg3 = wxString_in_helper(obj2);
41193 if (arg3 == NULL) SWIG_fail;
41194 temp3 = true;
41195 }
41196 {
41197 PyThreadState* __tstate = wxPyBeginAllowThreads();
41198 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41199 wxPyEndAllowThreads(__tstate);
41200 if (PyErr_Occurred()) SWIG_fail;
41201 }
41202 resultobj = SWIG_Py_Void();
41203 {
41204 if (temp3)
41205 delete arg3;
41206 }
41207 return resultobj;
41208 fail:
41209 {
41210 if (temp3)
41211 delete arg3;
41212 }
41213 return NULL;
41214 }
41215
41216
41217 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41218 PyObject *resultobj = 0;
41219 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41220 size_t arg2 ;
41221 wxString result;
41222 void *argp1 = 0 ;
41223 int res1 = 0 ;
41224 size_t val2 ;
41225 int ecode2 = 0 ;
41226 PyObject * obj0 = 0 ;
41227 PyObject * obj1 = 0 ;
41228 char * kwnames[] = {
41229 (char *) "self",(char *) "pos", NULL
41230 };
41231
41232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41234 if (!SWIG_IsOK(res1)) {
41235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41236 }
41237 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41238 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41239 if (!SWIG_IsOK(ecode2)) {
41240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41241 }
41242 arg2 = static_cast< size_t >(val2);
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 {
41250 #if wxUSE_UNICODE
41251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41252 #else
41253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41254 #endif
41255 }
41256 return resultobj;
41257 fail:
41258 return NULL;
41259 }
41260
41261
41262 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj = 0;
41264 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41265 wxString *arg2 = 0 ;
41266 wxString *arg3 = 0 ;
41267 int result;
41268 void *argp1 = 0 ;
41269 int res1 = 0 ;
41270 bool temp2 = false ;
41271 bool temp3 = false ;
41272 PyObject * obj0 = 0 ;
41273 PyObject * obj1 = 0 ;
41274 PyObject * obj2 = 0 ;
41275 char * kwnames[] = {
41276 (char *) "self",(char *) "menu",(char *) "item", NULL
41277 };
41278
41279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41281 if (!SWIG_IsOK(res1)) {
41282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41283 }
41284 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41285 {
41286 arg2 = wxString_in_helper(obj1);
41287 if (arg2 == NULL) SWIG_fail;
41288 temp2 = true;
41289 }
41290 {
41291 arg3 = wxString_in_helper(obj2);
41292 if (arg3 == NULL) SWIG_fail;
41293 temp3 = true;
41294 }
41295 {
41296 PyThreadState* __tstate = wxPyBeginAllowThreads();
41297 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41298 wxPyEndAllowThreads(__tstate);
41299 if (PyErr_Occurred()) SWIG_fail;
41300 }
41301 resultobj = SWIG_From_int(static_cast< int >(result));
41302 {
41303 if (temp2)
41304 delete arg2;
41305 }
41306 {
41307 if (temp3)
41308 delete arg3;
41309 }
41310 return resultobj;
41311 fail:
41312 {
41313 if (temp2)
41314 delete arg2;
41315 }
41316 {
41317 if (temp3)
41318 delete arg3;
41319 }
41320 return NULL;
41321 }
41322
41323
41324 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj = 0;
41326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41327 int arg2 ;
41328 wxMenuItem *result = 0 ;
41329 void *argp1 = 0 ;
41330 int res1 = 0 ;
41331 int val2 ;
41332 int ecode2 = 0 ;
41333 PyObject * obj0 = 0 ;
41334 PyObject * obj1 = 0 ;
41335 char * kwnames[] = {
41336 (char *) "self",(char *) "id", NULL
41337 };
41338
41339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41341 if (!SWIG_IsOK(res1)) {
41342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41343 }
41344 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41345 ecode2 = SWIG_AsVal_int(obj1, &val2);
41346 if (!SWIG_IsOK(ecode2)) {
41347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41348 }
41349 arg2 = static_cast< int >(val2);
41350 {
41351 PyThreadState* __tstate = wxPyBeginAllowThreads();
41352 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41353 wxPyEndAllowThreads(__tstate);
41354 if (PyErr_Occurred()) SWIG_fail;
41355 }
41356 {
41357 resultobj = wxPyMake_wxObject(result, (bool)0);
41358 }
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41366 PyObject *resultobj = 0;
41367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41368 wxString *arg2 = 0 ;
41369 int result;
41370 void *argp1 = 0 ;
41371 int res1 = 0 ;
41372 bool temp2 = false ;
41373 PyObject * obj0 = 0 ;
41374 PyObject * obj1 = 0 ;
41375 char * kwnames[] = {
41376 (char *) "self",(char *) "title", NULL
41377 };
41378
41379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41385 {
41386 arg2 = wxString_in_helper(obj1);
41387 if (arg2 == NULL) SWIG_fail;
41388 temp2 = true;
41389 }
41390 {
41391 PyThreadState* __tstate = wxPyBeginAllowThreads();
41392 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41393 wxPyEndAllowThreads(__tstate);
41394 if (PyErr_Occurred()) SWIG_fail;
41395 }
41396 resultobj = SWIG_From_int(static_cast< int >(result));
41397 {
41398 if (temp2)
41399 delete arg2;
41400 }
41401 return resultobj;
41402 fail:
41403 {
41404 if (temp2)
41405 delete arg2;
41406 }
41407 return NULL;
41408 }
41409
41410
41411 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41412 PyObject *resultobj = 0;
41413 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41414 int arg2 ;
41415 bool arg3 ;
41416 void *argp1 = 0 ;
41417 int res1 = 0 ;
41418 int val2 ;
41419 int ecode2 = 0 ;
41420 bool val3 ;
41421 int ecode3 = 0 ;
41422 PyObject * obj0 = 0 ;
41423 PyObject * obj1 = 0 ;
41424 PyObject * obj2 = 0 ;
41425 char * kwnames[] = {
41426 (char *) "self",(char *) "id",(char *) "enable", NULL
41427 };
41428
41429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41431 if (!SWIG_IsOK(res1)) {
41432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41433 }
41434 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41435 ecode2 = SWIG_AsVal_int(obj1, &val2);
41436 if (!SWIG_IsOK(ecode2)) {
41437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41438 }
41439 arg2 = static_cast< int >(val2);
41440 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41441 if (!SWIG_IsOK(ecode3)) {
41442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41443 }
41444 arg3 = static_cast< bool >(val3);
41445 {
41446 PyThreadState* __tstate = wxPyBeginAllowThreads();
41447 (arg1)->Enable(arg2,arg3);
41448 wxPyEndAllowThreads(__tstate);
41449 if (PyErr_Occurred()) SWIG_fail;
41450 }
41451 resultobj = SWIG_Py_Void();
41452 return resultobj;
41453 fail:
41454 return NULL;
41455 }
41456
41457
41458 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41459 PyObject *resultobj = 0;
41460 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41461 int arg2 ;
41462 bool arg3 ;
41463 void *argp1 = 0 ;
41464 int res1 = 0 ;
41465 int val2 ;
41466 int ecode2 = 0 ;
41467 bool val3 ;
41468 int ecode3 = 0 ;
41469 PyObject * obj0 = 0 ;
41470 PyObject * obj1 = 0 ;
41471 PyObject * obj2 = 0 ;
41472 char * kwnames[] = {
41473 (char *) "self",(char *) "id",(char *) "check", NULL
41474 };
41475
41476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41478 if (!SWIG_IsOK(res1)) {
41479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41480 }
41481 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41482 ecode2 = SWIG_AsVal_int(obj1, &val2);
41483 if (!SWIG_IsOK(ecode2)) {
41484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41485 }
41486 arg2 = static_cast< int >(val2);
41487 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41488 if (!SWIG_IsOK(ecode3)) {
41489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41490 }
41491 arg3 = static_cast< bool >(val3);
41492 {
41493 PyThreadState* __tstate = wxPyBeginAllowThreads();
41494 (arg1)->Check(arg2,arg3);
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 resultobj = SWIG_Py_Void();
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj = 0;
41507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41508 int arg2 ;
41509 bool result;
41510 void *argp1 = 0 ;
41511 int res1 = 0 ;
41512 int val2 ;
41513 int ecode2 = 0 ;
41514 PyObject * obj0 = 0 ;
41515 PyObject * obj1 = 0 ;
41516 char * kwnames[] = {
41517 (char *) "self",(char *) "id", NULL
41518 };
41519
41520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41522 if (!SWIG_IsOK(res1)) {
41523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41524 }
41525 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41526 ecode2 = SWIG_AsVal_int(obj1, &val2);
41527 if (!SWIG_IsOK(ecode2)) {
41528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41529 }
41530 arg2 = static_cast< int >(val2);
41531 {
41532 PyThreadState* __tstate = wxPyBeginAllowThreads();
41533 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41534 wxPyEndAllowThreads(__tstate);
41535 if (PyErr_Occurred()) SWIG_fail;
41536 }
41537 {
41538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41539 }
41540 return resultobj;
41541 fail:
41542 return NULL;
41543 }
41544
41545
41546 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41547 PyObject *resultobj = 0;
41548 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41549 int arg2 ;
41550 bool result;
41551 void *argp1 = 0 ;
41552 int res1 = 0 ;
41553 int val2 ;
41554 int ecode2 = 0 ;
41555 PyObject * obj0 = 0 ;
41556 PyObject * obj1 = 0 ;
41557 char * kwnames[] = {
41558 (char *) "self",(char *) "id", NULL
41559 };
41560
41561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41563 if (!SWIG_IsOK(res1)) {
41564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41565 }
41566 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41567 ecode2 = SWIG_AsVal_int(obj1, &val2);
41568 if (!SWIG_IsOK(ecode2)) {
41569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41570 }
41571 arg2 = static_cast< int >(val2);
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41575 wxPyEndAllowThreads(__tstate);
41576 if (PyErr_Occurred()) SWIG_fail;
41577 }
41578 {
41579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41580 }
41581 return resultobj;
41582 fail:
41583 return NULL;
41584 }
41585
41586
41587 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41588 PyObject *resultobj = 0;
41589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41590 int arg2 ;
41591 wxString *arg3 = 0 ;
41592 void *argp1 = 0 ;
41593 int res1 = 0 ;
41594 int val2 ;
41595 int ecode2 = 0 ;
41596 bool temp3 = false ;
41597 PyObject * obj0 = 0 ;
41598 PyObject * obj1 = 0 ;
41599 PyObject * obj2 = 0 ;
41600 char * kwnames[] = {
41601 (char *) "self",(char *) "id",(char *) "label", NULL
41602 };
41603
41604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41606 if (!SWIG_IsOK(res1)) {
41607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41608 }
41609 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41610 ecode2 = SWIG_AsVal_int(obj1, &val2);
41611 if (!SWIG_IsOK(ecode2)) {
41612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41613 }
41614 arg2 = static_cast< int >(val2);
41615 {
41616 arg3 = wxString_in_helper(obj2);
41617 if (arg3 == NULL) SWIG_fail;
41618 temp3 = true;
41619 }
41620 {
41621 PyThreadState* __tstate = wxPyBeginAllowThreads();
41622 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41623 wxPyEndAllowThreads(__tstate);
41624 if (PyErr_Occurred()) SWIG_fail;
41625 }
41626 resultobj = SWIG_Py_Void();
41627 {
41628 if (temp3)
41629 delete arg3;
41630 }
41631 return resultobj;
41632 fail:
41633 {
41634 if (temp3)
41635 delete arg3;
41636 }
41637 return NULL;
41638 }
41639
41640
41641 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41642 PyObject *resultobj = 0;
41643 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41644 int arg2 ;
41645 wxString result;
41646 void *argp1 = 0 ;
41647 int res1 = 0 ;
41648 int val2 ;
41649 int ecode2 = 0 ;
41650 PyObject * obj0 = 0 ;
41651 PyObject * obj1 = 0 ;
41652 char * kwnames[] = {
41653 (char *) "self",(char *) "id", NULL
41654 };
41655
41656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41658 if (!SWIG_IsOK(res1)) {
41659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41660 }
41661 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41662 ecode2 = SWIG_AsVal_int(obj1, &val2);
41663 if (!SWIG_IsOK(ecode2)) {
41664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41665 }
41666 arg2 = static_cast< int >(val2);
41667 {
41668 PyThreadState* __tstate = wxPyBeginAllowThreads();
41669 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41670 wxPyEndAllowThreads(__tstate);
41671 if (PyErr_Occurred()) SWIG_fail;
41672 }
41673 {
41674 #if wxUSE_UNICODE
41675 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41676 #else
41677 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41678 #endif
41679 }
41680 return resultobj;
41681 fail:
41682 return NULL;
41683 }
41684
41685
41686 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41687 PyObject *resultobj = 0;
41688 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41689 int arg2 ;
41690 wxString *arg3 = 0 ;
41691 void *argp1 = 0 ;
41692 int res1 = 0 ;
41693 int val2 ;
41694 int ecode2 = 0 ;
41695 bool temp3 = false ;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 PyObject * obj2 = 0 ;
41699 char * kwnames[] = {
41700 (char *) "self",(char *) "id",(char *) "helpString", NULL
41701 };
41702
41703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41707 }
41708 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41709 ecode2 = SWIG_AsVal_int(obj1, &val2);
41710 if (!SWIG_IsOK(ecode2)) {
41711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41712 }
41713 arg2 = static_cast< int >(val2);
41714 {
41715 arg3 = wxString_in_helper(obj2);
41716 if (arg3 == NULL) SWIG_fail;
41717 temp3 = true;
41718 }
41719 {
41720 PyThreadState* __tstate = wxPyBeginAllowThreads();
41721 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41722 wxPyEndAllowThreads(__tstate);
41723 if (PyErr_Occurred()) SWIG_fail;
41724 }
41725 resultobj = SWIG_Py_Void();
41726 {
41727 if (temp3)
41728 delete arg3;
41729 }
41730 return resultobj;
41731 fail:
41732 {
41733 if (temp3)
41734 delete arg3;
41735 }
41736 return NULL;
41737 }
41738
41739
41740 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41741 PyObject *resultobj = 0;
41742 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41743 int arg2 ;
41744 wxString result;
41745 void *argp1 = 0 ;
41746 int res1 = 0 ;
41747 int val2 ;
41748 int ecode2 = 0 ;
41749 PyObject * obj0 = 0 ;
41750 PyObject * obj1 = 0 ;
41751 char * kwnames[] = {
41752 (char *) "self",(char *) "id", NULL
41753 };
41754
41755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41757 if (!SWIG_IsOK(res1)) {
41758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41759 }
41760 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41761 ecode2 = SWIG_AsVal_int(obj1, &val2);
41762 if (!SWIG_IsOK(ecode2)) {
41763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41764 }
41765 arg2 = static_cast< int >(val2);
41766 {
41767 PyThreadState* __tstate = wxPyBeginAllowThreads();
41768 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41769 wxPyEndAllowThreads(__tstate);
41770 if (PyErr_Occurred()) SWIG_fail;
41771 }
41772 {
41773 #if wxUSE_UNICODE
41774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41775 #else
41776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41777 #endif
41778 }
41779 return resultobj;
41780 fail:
41781 return NULL;
41782 }
41783
41784
41785 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41786 PyObject *resultobj = 0;
41787 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41788 wxFrame *result = 0 ;
41789 void *argp1 = 0 ;
41790 int res1 = 0 ;
41791 PyObject *swig_obj[1] ;
41792
41793 if (!args) SWIG_fail;
41794 swig_obj[0] = args;
41795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41796 if (!SWIG_IsOK(res1)) {
41797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41798 }
41799 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41803 wxPyEndAllowThreads(__tstate);
41804 if (PyErr_Occurred()) SWIG_fail;
41805 }
41806 {
41807 resultobj = wxPyMake_wxObject(result, (bool)0);
41808 }
41809 return resultobj;
41810 fail:
41811 return NULL;
41812 }
41813
41814
41815 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41816 PyObject *resultobj = 0;
41817 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41818 bool result;
41819 void *argp1 = 0 ;
41820 int res1 = 0 ;
41821 PyObject *swig_obj[1] ;
41822
41823 if (!args) SWIG_fail;
41824 swig_obj[0] = args;
41825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41826 if (!SWIG_IsOK(res1)) {
41827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41828 }
41829 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41830 {
41831 PyThreadState* __tstate = wxPyBeginAllowThreads();
41832 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41833 wxPyEndAllowThreads(__tstate);
41834 if (PyErr_Occurred()) SWIG_fail;
41835 }
41836 {
41837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41838 }
41839 return resultobj;
41840 fail:
41841 return NULL;
41842 }
41843
41844
41845 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41846 PyObject *resultobj = 0;
41847 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41848 wxFrame *arg2 = (wxFrame *) 0 ;
41849 void *argp1 = 0 ;
41850 int res1 = 0 ;
41851 void *argp2 = 0 ;
41852 int res2 = 0 ;
41853 PyObject * obj0 = 0 ;
41854 PyObject * obj1 = 0 ;
41855 char * kwnames[] = {
41856 (char *) "self",(char *) "frame", NULL
41857 };
41858
41859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41861 if (!SWIG_IsOK(res1)) {
41862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41863 }
41864 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41866 if (!SWIG_IsOK(res2)) {
41867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41868 }
41869 arg2 = reinterpret_cast< wxFrame * >(argp2);
41870 {
41871 PyThreadState* __tstate = wxPyBeginAllowThreads();
41872 (arg1)->Attach(arg2);
41873 wxPyEndAllowThreads(__tstate);
41874 if (PyErr_Occurred()) SWIG_fail;
41875 }
41876 resultobj = SWIG_Py_Void();
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41884 PyObject *resultobj = 0;
41885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41886 void *argp1 = 0 ;
41887 int res1 = 0 ;
41888 PyObject *swig_obj[1] ;
41889
41890 if (!args) SWIG_fail;
41891 swig_obj[0] = args;
41892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41893 if (!SWIG_IsOK(res1)) {
41894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41895 }
41896 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41897 {
41898 PyThreadState* __tstate = wxPyBeginAllowThreads();
41899 (arg1)->Detach();
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 resultobj = SWIG_Py_Void();
41904 return resultobj;
41905 fail:
41906 return NULL;
41907 }
41908
41909
41910 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41911 PyObject *resultobj = 0;
41912 bool arg1 ;
41913 bool val1 ;
41914 int ecode1 = 0 ;
41915 PyObject * obj0 = 0 ;
41916 char * kwnames[] = {
41917 (char *) "enable", NULL
41918 };
41919
41920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41921 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41922 if (!SWIG_IsOK(ecode1)) {
41923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41924 }
41925 arg1 = static_cast< bool >(val1);
41926 {
41927 PyThreadState* __tstate = wxPyBeginAllowThreads();
41928 wxMenuBar_SetAutoWindowMenu(arg1);
41929 wxPyEndAllowThreads(__tstate);
41930 if (PyErr_Occurred()) SWIG_fail;
41931 }
41932 resultobj = SWIG_Py_Void();
41933 return resultobj;
41934 fail:
41935 return NULL;
41936 }
41937
41938
41939 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41940 PyObject *resultobj = 0;
41941 bool result;
41942
41943 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 result = (bool)wxMenuBar_GetAutoWindowMenu();
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 {
41951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41952 }
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41960 PyObject *obj;
41961 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41962 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41963 return SWIG_Py_Void();
41964 }
41965
41966 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41967 return SWIG_Python_InitShadowInstance(args);
41968 }
41969
41970 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41971 PyObject *resultobj = 0;
41972 wxMenu *arg1 = (wxMenu *) NULL ;
41973 int arg2 = (int) wxID_ANY ;
41974 wxString const &arg3_defvalue = wxPyEmptyString ;
41975 wxString *arg3 = (wxString *) &arg3_defvalue ;
41976 wxString const &arg4_defvalue = wxPyEmptyString ;
41977 wxString *arg4 = (wxString *) &arg4_defvalue ;
41978 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41979 wxMenu *arg6 = (wxMenu *) NULL ;
41980 wxMenuItem *result = 0 ;
41981 void *argp1 = 0 ;
41982 int res1 = 0 ;
41983 int val2 ;
41984 int ecode2 = 0 ;
41985 bool temp3 = false ;
41986 bool temp4 = false ;
41987 int val5 ;
41988 int ecode5 = 0 ;
41989 void *argp6 = 0 ;
41990 int res6 = 0 ;
41991 PyObject * obj0 = 0 ;
41992 PyObject * obj1 = 0 ;
41993 PyObject * obj2 = 0 ;
41994 PyObject * obj3 = 0 ;
41995 PyObject * obj4 = 0 ;
41996 PyObject * obj5 = 0 ;
41997 char * kwnames[] = {
41998 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41999 };
42000
42001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42002 if (obj0) {
42003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42004 if (!SWIG_IsOK(res1)) {
42005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42006 }
42007 arg1 = reinterpret_cast< wxMenu * >(argp1);
42008 }
42009 if (obj1) {
42010 ecode2 = SWIG_AsVal_int(obj1, &val2);
42011 if (!SWIG_IsOK(ecode2)) {
42012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42013 }
42014 arg2 = static_cast< int >(val2);
42015 }
42016 if (obj2) {
42017 {
42018 arg3 = wxString_in_helper(obj2);
42019 if (arg3 == NULL) SWIG_fail;
42020 temp3 = true;
42021 }
42022 }
42023 if (obj3) {
42024 {
42025 arg4 = wxString_in_helper(obj3);
42026 if (arg4 == NULL) SWIG_fail;
42027 temp4 = true;
42028 }
42029 }
42030 if (obj4) {
42031 ecode5 = SWIG_AsVal_int(obj4, &val5);
42032 if (!SWIG_IsOK(ecode5)) {
42033 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42034 }
42035 arg5 = static_cast< wxItemKind >(val5);
42036 }
42037 if (obj5) {
42038 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42039 if (!SWIG_IsOK(res6)) {
42040 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42041 }
42042 arg6 = reinterpret_cast< wxMenu * >(argp6);
42043 }
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 {
42051 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42052 }
42053 {
42054 if (temp3)
42055 delete arg3;
42056 }
42057 {
42058 if (temp4)
42059 delete arg4;
42060 }
42061 return resultobj;
42062 fail:
42063 {
42064 if (temp3)
42065 delete arg3;
42066 }
42067 {
42068 if (temp4)
42069 delete arg4;
42070 }
42071 return NULL;
42072 }
42073
42074
42075 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42076 PyObject *resultobj = 0;
42077 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42078 void *argp1 = 0 ;
42079 int res1 = 0 ;
42080 PyObject *swig_obj[1] ;
42081
42082 if (!args) SWIG_fail;
42083 swig_obj[0] = args;
42084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42085 if (!SWIG_IsOK(res1)) {
42086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42087 }
42088 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42089 {
42090 PyThreadState* __tstate = wxPyBeginAllowThreads();
42091 delete arg1;
42092
42093 wxPyEndAllowThreads(__tstate);
42094 if (PyErr_Occurred()) SWIG_fail;
42095 }
42096 resultobj = SWIG_Py_Void();
42097 return resultobj;
42098 fail:
42099 return NULL;
42100 }
42101
42102
42103 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42104 PyObject *resultobj = 0;
42105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42106 wxMenu *result = 0 ;
42107 void *argp1 = 0 ;
42108 int res1 = 0 ;
42109 PyObject *swig_obj[1] ;
42110
42111 if (!args) SWIG_fail;
42112 swig_obj[0] = args;
42113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42114 if (!SWIG_IsOK(res1)) {
42115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42116 }
42117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42118 {
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 {
42125 resultobj = wxPyMake_wxObject(result, 0);
42126 }
42127 return resultobj;
42128 fail:
42129 return NULL;
42130 }
42131
42132
42133 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42134 PyObject *resultobj = 0;
42135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42136 wxMenu *arg2 = (wxMenu *) 0 ;
42137 void *argp1 = 0 ;
42138 int res1 = 0 ;
42139 void *argp2 = 0 ;
42140 int res2 = 0 ;
42141 PyObject * obj0 = 0 ;
42142 PyObject * obj1 = 0 ;
42143 char * kwnames[] = {
42144 (char *) "self",(char *) "menu", NULL
42145 };
42146
42147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42149 if (!SWIG_IsOK(res1)) {
42150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42151 }
42152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42154 if (!SWIG_IsOK(res2)) {
42155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42156 }
42157 arg2 = reinterpret_cast< wxMenu * >(argp2);
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 (arg1)->SetMenu(arg2);
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 resultobj = SWIG_Py_Void();
42165 return resultobj;
42166 fail:
42167 return NULL;
42168 }
42169
42170
42171 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42172 PyObject *resultobj = 0;
42173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42174 int arg2 ;
42175 void *argp1 = 0 ;
42176 int res1 = 0 ;
42177 int val2 ;
42178 int ecode2 = 0 ;
42179 PyObject * obj0 = 0 ;
42180 PyObject * obj1 = 0 ;
42181 char * kwnames[] = {
42182 (char *) "self",(char *) "id", NULL
42183 };
42184
42185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42187 if (!SWIG_IsOK(res1)) {
42188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42189 }
42190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42191 ecode2 = SWIG_AsVal_int(obj1, &val2);
42192 if (!SWIG_IsOK(ecode2)) {
42193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42194 }
42195 arg2 = static_cast< int >(val2);
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 (arg1)->SetId(arg2);
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 resultobj = SWIG_Py_Void();
42203 return resultobj;
42204 fail:
42205 return NULL;
42206 }
42207
42208
42209 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42210 PyObject *resultobj = 0;
42211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42212 int result;
42213 void *argp1 = 0 ;
42214 int res1 = 0 ;
42215 PyObject *swig_obj[1] ;
42216
42217 if (!args) SWIG_fail;
42218 swig_obj[0] = args;
42219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42220 if (!SWIG_IsOK(res1)) {
42221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42222 }
42223 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = (int)((wxMenuItem const *)arg1)->GetId();
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 resultobj = SWIG_From_int(static_cast< int >(result));
42231 return resultobj;
42232 fail:
42233 return NULL;
42234 }
42235
42236
42237 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42238 PyObject *resultobj = 0;
42239 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42240 bool result;
42241 void *argp1 = 0 ;
42242 int res1 = 0 ;
42243 PyObject *swig_obj[1] ;
42244
42245 if (!args) SWIG_fail;
42246 swig_obj[0] = args;
42247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42248 if (!SWIG_IsOK(res1)) {
42249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42250 }
42251 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42252 {
42253 PyThreadState* __tstate = wxPyBeginAllowThreads();
42254 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42255 wxPyEndAllowThreads(__tstate);
42256 if (PyErr_Occurred()) SWIG_fail;
42257 }
42258 {
42259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42260 }
42261 return resultobj;
42262 fail:
42263 return NULL;
42264 }
42265
42266
42267 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42268 PyObject *resultobj = 0;
42269 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42270 wxString *arg2 = 0 ;
42271 void *argp1 = 0 ;
42272 int res1 = 0 ;
42273 bool temp2 = false ;
42274 PyObject * obj0 = 0 ;
42275 PyObject * obj1 = 0 ;
42276 char * kwnames[] = {
42277 (char *) "self",(char *) "str", NULL
42278 };
42279
42280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42282 if (!SWIG_IsOK(res1)) {
42283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42284 }
42285 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42286 {
42287 arg2 = wxString_in_helper(obj1);
42288 if (arg2 == NULL) SWIG_fail;
42289 temp2 = true;
42290 }
42291 {
42292 PyThreadState* __tstate = wxPyBeginAllowThreads();
42293 (arg1)->SetText((wxString const &)*arg2);
42294 wxPyEndAllowThreads(__tstate);
42295 if (PyErr_Occurred()) SWIG_fail;
42296 }
42297 resultobj = SWIG_Py_Void();
42298 {
42299 if (temp2)
42300 delete arg2;
42301 }
42302 return resultobj;
42303 fail:
42304 {
42305 if (temp2)
42306 delete arg2;
42307 }
42308 return NULL;
42309 }
42310
42311
42312 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42313 PyObject *resultobj = 0;
42314 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42315 wxString result;
42316 void *argp1 = 0 ;
42317 int res1 = 0 ;
42318 PyObject *swig_obj[1] ;
42319
42320 if (!args) SWIG_fail;
42321 swig_obj[0] = args;
42322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42323 if (!SWIG_IsOK(res1)) {
42324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42325 }
42326 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42327 {
42328 PyThreadState* __tstate = wxPyBeginAllowThreads();
42329 result = ((wxMenuItem const *)arg1)->GetLabel();
42330 wxPyEndAllowThreads(__tstate);
42331 if (PyErr_Occurred()) SWIG_fail;
42332 }
42333 {
42334 #if wxUSE_UNICODE
42335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42336 #else
42337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42338 #endif
42339 }
42340 return resultobj;
42341 fail:
42342 return NULL;
42343 }
42344
42345
42346 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42347 PyObject *resultobj = 0;
42348 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42349 wxString *result = 0 ;
42350 void *argp1 = 0 ;
42351 int res1 = 0 ;
42352 PyObject *swig_obj[1] ;
42353
42354 if (!args) SWIG_fail;
42355 swig_obj[0] = args;
42356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42357 if (!SWIG_IsOK(res1)) {
42358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42359 }
42360 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42361 {
42362 PyThreadState* __tstate = wxPyBeginAllowThreads();
42363 {
42364 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42365 result = (wxString *) &_result_ref;
42366 }
42367 wxPyEndAllowThreads(__tstate);
42368 if (PyErr_Occurred()) SWIG_fail;
42369 }
42370 {
42371 #if wxUSE_UNICODE
42372 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42373 #else
42374 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42375 #endif
42376 }
42377 return resultobj;
42378 fail:
42379 return NULL;
42380 }
42381
42382
42383 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42384 PyObject *resultobj = 0;
42385 wxString *arg1 = 0 ;
42386 wxString result;
42387 bool temp1 = false ;
42388 PyObject * obj0 = 0 ;
42389 char * kwnames[] = {
42390 (char *) "text", NULL
42391 };
42392
42393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42394 {
42395 arg1 = wxString_in_helper(obj0);
42396 if (arg1 == NULL) SWIG_fail;
42397 temp1 = true;
42398 }
42399 {
42400 PyThreadState* __tstate = wxPyBeginAllowThreads();
42401 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42402 wxPyEndAllowThreads(__tstate);
42403 if (PyErr_Occurred()) SWIG_fail;
42404 }
42405 {
42406 #if wxUSE_UNICODE
42407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42408 #else
42409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42410 #endif
42411 }
42412 {
42413 if (temp1)
42414 delete arg1;
42415 }
42416 return resultobj;
42417 fail:
42418 {
42419 if (temp1)
42420 delete arg1;
42421 }
42422 return NULL;
42423 }
42424
42425
42426 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42427 PyObject *resultobj = 0;
42428 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42429 wxItemKind result;
42430 void *argp1 = 0 ;
42431 int res1 = 0 ;
42432 PyObject *swig_obj[1] ;
42433
42434 if (!args) SWIG_fail;
42435 swig_obj[0] = args;
42436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42437 if (!SWIG_IsOK(res1)) {
42438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42439 }
42440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42444 wxPyEndAllowThreads(__tstate);
42445 if (PyErr_Occurred()) SWIG_fail;
42446 }
42447 resultobj = SWIG_From_int(static_cast< int >(result));
42448 return resultobj;
42449 fail:
42450 return NULL;
42451 }
42452
42453
42454 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42455 PyObject *resultobj = 0;
42456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42457 wxItemKind arg2 ;
42458 void *argp1 = 0 ;
42459 int res1 = 0 ;
42460 int val2 ;
42461 int ecode2 = 0 ;
42462 PyObject * obj0 = 0 ;
42463 PyObject * obj1 = 0 ;
42464 char * kwnames[] = {
42465 (char *) "self",(char *) "kind", NULL
42466 };
42467
42468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42470 if (!SWIG_IsOK(res1)) {
42471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42472 }
42473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42474 ecode2 = SWIG_AsVal_int(obj1, &val2);
42475 if (!SWIG_IsOK(ecode2)) {
42476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42477 }
42478 arg2 = static_cast< wxItemKind >(val2);
42479 {
42480 PyThreadState* __tstate = wxPyBeginAllowThreads();
42481 (arg1)->SetKind(arg2);
42482 wxPyEndAllowThreads(__tstate);
42483 if (PyErr_Occurred()) SWIG_fail;
42484 }
42485 resultobj = SWIG_Py_Void();
42486 return resultobj;
42487 fail:
42488 return NULL;
42489 }
42490
42491
42492 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42493 PyObject *resultobj = 0;
42494 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42495 bool arg2 ;
42496 void *argp1 = 0 ;
42497 int res1 = 0 ;
42498 bool val2 ;
42499 int ecode2 = 0 ;
42500 PyObject * obj0 = 0 ;
42501 PyObject * obj1 = 0 ;
42502 char * kwnames[] = {
42503 (char *) "self",(char *) "checkable", NULL
42504 };
42505
42506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42510 }
42511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42513 if (!SWIG_IsOK(ecode2)) {
42514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42515 }
42516 arg2 = static_cast< bool >(val2);
42517 {
42518 PyThreadState* __tstate = wxPyBeginAllowThreads();
42519 (arg1)->SetCheckable(arg2);
42520 wxPyEndAllowThreads(__tstate);
42521 if (PyErr_Occurred()) SWIG_fail;
42522 }
42523 resultobj = SWIG_Py_Void();
42524 return resultobj;
42525 fail:
42526 return NULL;
42527 }
42528
42529
42530 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42531 PyObject *resultobj = 0;
42532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42533 bool result;
42534 void *argp1 = 0 ;
42535 int res1 = 0 ;
42536 PyObject *swig_obj[1] ;
42537
42538 if (!args) SWIG_fail;
42539 swig_obj[0] = args;
42540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42541 if (!SWIG_IsOK(res1)) {
42542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42543 }
42544 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42545 {
42546 PyThreadState* __tstate = wxPyBeginAllowThreads();
42547 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42548 wxPyEndAllowThreads(__tstate);
42549 if (PyErr_Occurred()) SWIG_fail;
42550 }
42551 {
42552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42553 }
42554 return resultobj;
42555 fail:
42556 return NULL;
42557 }
42558
42559
42560 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42561 PyObject *resultobj = 0;
42562 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42563 bool result;
42564 void *argp1 = 0 ;
42565 int res1 = 0 ;
42566 PyObject *swig_obj[1] ;
42567
42568 if (!args) SWIG_fail;
42569 swig_obj[0] = args;
42570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42571 if (!SWIG_IsOK(res1)) {
42572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42573 }
42574 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42583 }
42584 return resultobj;
42585 fail:
42586 return NULL;
42587 }
42588
42589
42590 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42591 PyObject *resultobj = 0;
42592 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42593 wxMenu *arg2 = (wxMenu *) 0 ;
42594 void *argp1 = 0 ;
42595 int res1 = 0 ;
42596 void *argp2 = 0 ;
42597 int res2 = 0 ;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 char * kwnames[] = {
42601 (char *) "self",(char *) "menu", NULL
42602 };
42603
42604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42611 if (!SWIG_IsOK(res2)) {
42612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42613 }
42614 arg2 = reinterpret_cast< wxMenu * >(argp2);
42615 {
42616 PyThreadState* __tstate = wxPyBeginAllowThreads();
42617 (arg1)->SetSubMenu(arg2);
42618 wxPyEndAllowThreads(__tstate);
42619 if (PyErr_Occurred()) SWIG_fail;
42620 }
42621 resultobj = SWIG_Py_Void();
42622 return resultobj;
42623 fail:
42624 return NULL;
42625 }
42626
42627
42628 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42629 PyObject *resultobj = 0;
42630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42631 wxMenu *result = 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 {
42650 resultobj = wxPyMake_wxObject(result, 0);
42651 }
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj = 0;
42660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42661 bool arg2 = (bool) true ;
42662 void *argp1 = 0 ;
42663 int res1 = 0 ;
42664 bool val2 ;
42665 int ecode2 = 0 ;
42666 PyObject * obj0 = 0 ;
42667 PyObject * obj1 = 0 ;
42668 char * kwnames[] = {
42669 (char *) "self",(char *) "enable", NULL
42670 };
42671
42672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42674 if (!SWIG_IsOK(res1)) {
42675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42676 }
42677 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42678 if (obj1) {
42679 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42680 if (!SWIG_IsOK(ecode2)) {
42681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42682 }
42683 arg2 = static_cast< bool >(val2);
42684 }
42685 {
42686 PyThreadState* __tstate = wxPyBeginAllowThreads();
42687 (arg1)->Enable(arg2);
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 resultobj = SWIG_Py_Void();
42692 return resultobj;
42693 fail:
42694 return NULL;
42695 }
42696
42697
42698 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42699 PyObject *resultobj = 0;
42700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42701 bool result;
42702 void *argp1 = 0 ;
42703 int res1 = 0 ;
42704 PyObject *swig_obj[1] ;
42705
42706 if (!args) SWIG_fail;
42707 swig_obj[0] = args;
42708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42709 if (!SWIG_IsOK(res1)) {
42710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42711 }
42712 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42713 {
42714 PyThreadState* __tstate = wxPyBeginAllowThreads();
42715 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42716 wxPyEndAllowThreads(__tstate);
42717 if (PyErr_Occurred()) SWIG_fail;
42718 }
42719 {
42720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42721 }
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42729 PyObject *resultobj = 0;
42730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42731 bool arg2 = (bool) true ;
42732 void *argp1 = 0 ;
42733 int res1 = 0 ;
42734 bool val2 ;
42735 int ecode2 = 0 ;
42736 PyObject * obj0 = 0 ;
42737 PyObject * obj1 = 0 ;
42738 char * kwnames[] = {
42739 (char *) "self",(char *) "check", NULL
42740 };
42741
42742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42744 if (!SWIG_IsOK(res1)) {
42745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42746 }
42747 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42748 if (obj1) {
42749 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42750 if (!SWIG_IsOK(ecode2)) {
42751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42752 }
42753 arg2 = static_cast< bool >(val2);
42754 }
42755 {
42756 PyThreadState* __tstate = wxPyBeginAllowThreads();
42757 (arg1)->Check(arg2);
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 resultobj = SWIG_Py_Void();
42762 return resultobj;
42763 fail:
42764 return NULL;
42765 }
42766
42767
42768 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42769 PyObject *resultobj = 0;
42770 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42771 bool result;
42772 void *argp1 = 0 ;
42773 int res1 = 0 ;
42774 PyObject *swig_obj[1] ;
42775
42776 if (!args) SWIG_fail;
42777 swig_obj[0] = args;
42778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42779 if (!SWIG_IsOK(res1)) {
42780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42781 }
42782 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42783 {
42784 PyThreadState* __tstate = wxPyBeginAllowThreads();
42785 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42786 wxPyEndAllowThreads(__tstate);
42787 if (PyErr_Occurred()) SWIG_fail;
42788 }
42789 {
42790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42791 }
42792 return resultobj;
42793 fail:
42794 return NULL;
42795 }
42796
42797
42798 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42799 PyObject *resultobj = 0;
42800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42801 void *argp1 = 0 ;
42802 int res1 = 0 ;
42803 PyObject *swig_obj[1] ;
42804
42805 if (!args) SWIG_fail;
42806 swig_obj[0] = args;
42807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42808 if (!SWIG_IsOK(res1)) {
42809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42810 }
42811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42812 {
42813 PyThreadState* __tstate = wxPyBeginAllowThreads();
42814 (arg1)->Toggle();
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 resultobj = SWIG_Py_Void();
42819 return resultobj;
42820 fail:
42821 return NULL;
42822 }
42823
42824
42825 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42826 PyObject *resultobj = 0;
42827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42828 wxString *arg2 = 0 ;
42829 void *argp1 = 0 ;
42830 int res1 = 0 ;
42831 bool temp2 = false ;
42832 PyObject * obj0 = 0 ;
42833 PyObject * obj1 = 0 ;
42834 char * kwnames[] = {
42835 (char *) "self",(char *) "str", NULL
42836 };
42837
42838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42840 if (!SWIG_IsOK(res1)) {
42841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42842 }
42843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42844 {
42845 arg2 = wxString_in_helper(obj1);
42846 if (arg2 == NULL) SWIG_fail;
42847 temp2 = true;
42848 }
42849 {
42850 PyThreadState* __tstate = wxPyBeginAllowThreads();
42851 (arg1)->SetHelp((wxString const &)*arg2);
42852 wxPyEndAllowThreads(__tstate);
42853 if (PyErr_Occurred()) SWIG_fail;
42854 }
42855 resultobj = SWIG_Py_Void();
42856 {
42857 if (temp2)
42858 delete arg2;
42859 }
42860 return resultobj;
42861 fail:
42862 {
42863 if (temp2)
42864 delete arg2;
42865 }
42866 return NULL;
42867 }
42868
42869
42870 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42871 PyObject *resultobj = 0;
42872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42873 wxString *result = 0 ;
42874 void *argp1 = 0 ;
42875 int res1 = 0 ;
42876 PyObject *swig_obj[1] ;
42877
42878 if (!args) SWIG_fail;
42879 swig_obj[0] = args;
42880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42881 if (!SWIG_IsOK(res1)) {
42882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42883 }
42884 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42885 {
42886 PyThreadState* __tstate = wxPyBeginAllowThreads();
42887 {
42888 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42889 result = (wxString *) &_result_ref;
42890 }
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 {
42895 #if wxUSE_UNICODE
42896 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42897 #else
42898 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42899 #endif
42900 }
42901 return resultobj;
42902 fail:
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42908 PyObject *resultobj = 0;
42909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42910 wxAcceleratorEntry *result = 0 ;
42911 void *argp1 = 0 ;
42912 int res1 = 0 ;
42913 PyObject *swig_obj[1] ;
42914
42915 if (!args) SWIG_fail;
42916 swig_obj[0] = args;
42917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42918 if (!SWIG_IsOK(res1)) {
42919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42920 }
42921 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42925 wxPyEndAllowThreads(__tstate);
42926 if (PyErr_Occurred()) SWIG_fail;
42927 }
42928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42936 PyObject *resultobj = 0;
42937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42938 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42939 void *argp1 = 0 ;
42940 int res1 = 0 ;
42941 void *argp2 = 0 ;
42942 int res2 = 0 ;
42943 PyObject * obj0 = 0 ;
42944 PyObject * obj1 = 0 ;
42945 char * kwnames[] = {
42946 (char *) "self",(char *) "accel", NULL
42947 };
42948
42949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42951 if (!SWIG_IsOK(res1)) {
42952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42953 }
42954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42956 if (!SWIG_IsOK(res2)) {
42957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42958 }
42959 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 (arg1)->SetAccel(arg2);
42963 wxPyEndAllowThreads(__tstate);
42964 if (PyErr_Occurred()) SWIG_fail;
42965 }
42966 resultobj = SWIG_Py_Void();
42967 return resultobj;
42968 fail:
42969 return NULL;
42970 }
42971
42972
42973 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42974 PyObject *resultobj = 0;
42975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42976 wxBitmap *arg2 = 0 ;
42977 void *argp1 = 0 ;
42978 int res1 = 0 ;
42979 void *argp2 = 0 ;
42980 int res2 = 0 ;
42981 PyObject * obj0 = 0 ;
42982 PyObject * obj1 = 0 ;
42983 char * kwnames[] = {
42984 (char *) "self",(char *) "bitmap", NULL
42985 };
42986
42987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42989 if (!SWIG_IsOK(res1)) {
42990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42991 }
42992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42993 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42994 if (!SWIG_IsOK(res2)) {
42995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42996 }
42997 if (!argp2) {
42998 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42999 }
43000 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43001 {
43002 PyThreadState* __tstate = wxPyBeginAllowThreads();
43003 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 resultobj = SWIG_Py_Void();
43008 return resultobj;
43009 fail:
43010 return NULL;
43011 }
43012
43013
43014 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43015 PyObject *resultobj = 0;
43016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43017 wxBitmap *result = 0 ;
43018 void *argp1 = 0 ;
43019 int res1 = 0 ;
43020 PyObject *swig_obj[1] ;
43021
43022 if (!args) SWIG_fail;
43023 swig_obj[0] = args;
43024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43025 if (!SWIG_IsOK(res1)) {
43026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43027 }
43028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 {
43032 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43033 result = (wxBitmap *) &_result_ref;
43034 }
43035 wxPyEndAllowThreads(__tstate);
43036 if (PyErr_Occurred()) SWIG_fail;
43037 }
43038 {
43039 wxBitmap* resultptr = new wxBitmap(*result);
43040 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43041 }
43042 return resultobj;
43043 fail:
43044 return NULL;
43045 }
43046
43047
43048 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43049 PyObject *resultobj = 0;
43050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43051 wxFont *arg2 = 0 ;
43052 void *argp1 = 0 ;
43053 int res1 = 0 ;
43054 void *argp2 = 0 ;
43055 int res2 = 0 ;
43056 PyObject * obj0 = 0 ;
43057 PyObject * obj1 = 0 ;
43058 char * kwnames[] = {
43059 (char *) "self",(char *) "font", NULL
43060 };
43061
43062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43064 if (!SWIG_IsOK(res1)) {
43065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43066 }
43067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43068 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43069 if (!SWIG_IsOK(res2)) {
43070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43071 }
43072 if (!argp2) {
43073 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43074 }
43075 arg2 = reinterpret_cast< wxFont * >(argp2);
43076 {
43077 PyThreadState* __tstate = wxPyBeginAllowThreads();
43078 (arg1)->SetFont((wxFont const &)*arg2);
43079 wxPyEndAllowThreads(__tstate);
43080 if (PyErr_Occurred()) SWIG_fail;
43081 }
43082 resultobj = SWIG_Py_Void();
43083 return resultobj;
43084 fail:
43085 return NULL;
43086 }
43087
43088
43089 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43090 PyObject *resultobj = 0;
43091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43092 wxFont result;
43093 void *argp1 = 0 ;
43094 int res1 = 0 ;
43095 PyObject *swig_obj[1] ;
43096
43097 if (!args) SWIG_fail;
43098 swig_obj[0] = args;
43099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43100 if (!SWIG_IsOK(res1)) {
43101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43102 }
43103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43104 {
43105 PyThreadState* __tstate = wxPyBeginAllowThreads();
43106 result = (arg1)->GetFont();
43107 wxPyEndAllowThreads(__tstate);
43108 if (PyErr_Occurred()) SWIG_fail;
43109 }
43110 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43111 return resultobj;
43112 fail:
43113 return NULL;
43114 }
43115
43116
43117 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43118 PyObject *resultobj = 0;
43119 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43120 wxColour *arg2 = 0 ;
43121 void *argp1 = 0 ;
43122 int res1 = 0 ;
43123 wxColour temp2 ;
43124 PyObject * obj0 = 0 ;
43125 PyObject * obj1 = 0 ;
43126 char * kwnames[] = {
43127 (char *) "self",(char *) "colText", NULL
43128 };
43129
43130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43132 if (!SWIG_IsOK(res1)) {
43133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43134 }
43135 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43136 {
43137 arg2 = &temp2;
43138 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43139 }
43140 {
43141 PyThreadState* __tstate = wxPyBeginAllowThreads();
43142 (arg1)->SetTextColour((wxColour const &)*arg2);
43143 wxPyEndAllowThreads(__tstate);
43144 if (PyErr_Occurred()) SWIG_fail;
43145 }
43146 resultobj = SWIG_Py_Void();
43147 return resultobj;
43148 fail:
43149 return NULL;
43150 }
43151
43152
43153 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43154 PyObject *resultobj = 0;
43155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43156 wxColour result;
43157 void *argp1 = 0 ;
43158 int res1 = 0 ;
43159 PyObject *swig_obj[1] ;
43160
43161 if (!args) SWIG_fail;
43162 swig_obj[0] = args;
43163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43164 if (!SWIG_IsOK(res1)) {
43165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43166 }
43167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43168 {
43169 PyThreadState* __tstate = wxPyBeginAllowThreads();
43170 result = (arg1)->GetTextColour();
43171 wxPyEndAllowThreads(__tstate);
43172 if (PyErr_Occurred()) SWIG_fail;
43173 }
43174 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43182 PyObject *resultobj = 0;
43183 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43184 wxColour *arg2 = 0 ;
43185 void *argp1 = 0 ;
43186 int res1 = 0 ;
43187 wxColour temp2 ;
43188 PyObject * obj0 = 0 ;
43189 PyObject * obj1 = 0 ;
43190 char * kwnames[] = {
43191 (char *) "self",(char *) "colBack", NULL
43192 };
43193
43194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43196 if (!SWIG_IsOK(res1)) {
43197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43198 }
43199 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43200 {
43201 arg2 = &temp2;
43202 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43203 }
43204 {
43205 PyThreadState* __tstate = wxPyBeginAllowThreads();
43206 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43207 wxPyEndAllowThreads(__tstate);
43208 if (PyErr_Occurred()) SWIG_fail;
43209 }
43210 resultobj = SWIG_Py_Void();
43211 return resultobj;
43212 fail:
43213 return NULL;
43214 }
43215
43216
43217 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43218 PyObject *resultobj = 0;
43219 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43220 wxColour result;
43221 void *argp1 = 0 ;
43222 int res1 = 0 ;
43223 PyObject *swig_obj[1] ;
43224
43225 if (!args) SWIG_fail;
43226 swig_obj[0] = args;
43227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43228 if (!SWIG_IsOK(res1)) {
43229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43230 }
43231 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 result = (arg1)->GetBackgroundColour();
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43246 PyObject *resultobj = 0;
43247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43248 wxBitmap *arg2 = 0 ;
43249 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43250 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 void *argp2 = 0 ;
43254 int res2 = 0 ;
43255 void *argp3 = 0 ;
43256 int res3 = 0 ;
43257 PyObject * obj0 = 0 ;
43258 PyObject * obj1 = 0 ;
43259 PyObject * obj2 = 0 ;
43260 char * kwnames[] = {
43261 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43262 };
43263
43264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43266 if (!SWIG_IsOK(res1)) {
43267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43268 }
43269 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43270 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43271 if (!SWIG_IsOK(res2)) {
43272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43273 }
43274 if (!argp2) {
43275 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43276 }
43277 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43278 if (obj2) {
43279 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43280 if (!SWIG_IsOK(res3)) {
43281 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43282 }
43283 if (!argp3) {
43284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43285 }
43286 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43287 }
43288 {
43289 PyThreadState* __tstate = wxPyBeginAllowThreads();
43290 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43291 wxPyEndAllowThreads(__tstate);
43292 if (PyErr_Occurred()) SWIG_fail;
43293 }
43294 resultobj = SWIG_Py_Void();
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43302 PyObject *resultobj = 0;
43303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43304 wxBitmap *arg2 = 0 ;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 void *argp2 = 0 ;
43308 int res2 = 0 ;
43309 PyObject * obj0 = 0 ;
43310 PyObject * obj1 = 0 ;
43311 char * kwnames[] = {
43312 (char *) "self",(char *) "bmpDisabled", NULL
43313 };
43314
43315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43317 if (!SWIG_IsOK(res1)) {
43318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43319 }
43320 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43321 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43322 if (!SWIG_IsOK(res2)) {
43323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43324 }
43325 if (!argp2) {
43326 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43327 }
43328 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43329 {
43330 PyThreadState* __tstate = wxPyBeginAllowThreads();
43331 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43332 wxPyEndAllowThreads(__tstate);
43333 if (PyErr_Occurred()) SWIG_fail;
43334 }
43335 resultobj = SWIG_Py_Void();
43336 return resultobj;
43337 fail:
43338 return NULL;
43339 }
43340
43341
43342 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43343 PyObject *resultobj = 0;
43344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43345 wxBitmap *result = 0 ;
43346 void *argp1 = 0 ;
43347 int res1 = 0 ;
43348 PyObject *swig_obj[1] ;
43349
43350 if (!args) SWIG_fail;
43351 swig_obj[0] = args;
43352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43353 if (!SWIG_IsOK(res1)) {
43354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43355 }
43356 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43357 {
43358 PyThreadState* __tstate = wxPyBeginAllowThreads();
43359 {
43360 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43361 result = (wxBitmap *) &_result_ref;
43362 }
43363 wxPyEndAllowThreads(__tstate);
43364 if (PyErr_Occurred()) SWIG_fail;
43365 }
43366 {
43367 wxBitmap* resultptr = new wxBitmap(*result);
43368 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43369 }
43370 return resultobj;
43371 fail:
43372 return NULL;
43373 }
43374
43375
43376 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43377 PyObject *resultobj = 0;
43378 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43379 int arg2 ;
43380 void *argp1 = 0 ;
43381 int res1 = 0 ;
43382 int val2 ;
43383 int ecode2 = 0 ;
43384 PyObject * obj0 = 0 ;
43385 PyObject * obj1 = 0 ;
43386 char * kwnames[] = {
43387 (char *) "self",(char *) "nWidth", NULL
43388 };
43389
43390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",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_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43394 }
43395 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43396 ecode2 = SWIG_AsVal_int(obj1, &val2);
43397 if (!SWIG_IsOK(ecode2)) {
43398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43399 }
43400 arg2 = static_cast< int >(val2);
43401 {
43402 PyThreadState* __tstate = wxPyBeginAllowThreads();
43403 (arg1)->SetMarginWidth(arg2);
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 resultobj = SWIG_Py_Void();
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43415 PyObject *resultobj = 0;
43416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43417 int result;
43418 void *argp1 = 0 ;
43419 int res1 = 0 ;
43420 PyObject *swig_obj[1] ;
43421
43422 if (!args) SWIG_fail;
43423 swig_obj[0] = args;
43424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43425 if (!SWIG_IsOK(res1)) {
43426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43427 }
43428 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43429 {
43430 PyThreadState* __tstate = wxPyBeginAllowThreads();
43431 result = (int)(arg1)->GetMarginWidth();
43432 wxPyEndAllowThreads(__tstate);
43433 if (PyErr_Occurred()) SWIG_fail;
43434 }
43435 resultobj = SWIG_From_int(static_cast< int >(result));
43436 return resultobj;
43437 fail:
43438 return NULL;
43439 }
43440
43441
43442 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43443 PyObject *resultobj = 0;
43444 int result;
43445
43446 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43447 {
43448 PyThreadState* __tstate = wxPyBeginAllowThreads();
43449 result = (int)wxMenuItem::GetDefaultMarginWidth();
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 resultobj = SWIG_From_int(static_cast< int >(result));
43454 return resultobj;
43455 fail:
43456 return NULL;
43457 }
43458
43459
43460 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43461 PyObject *resultobj = 0;
43462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43463 bool result;
43464 void *argp1 = 0 ;
43465 int res1 = 0 ;
43466 PyObject *swig_obj[1] ;
43467
43468 if (!args) SWIG_fail;
43469 swig_obj[0] = args;
43470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43471 if (!SWIG_IsOK(res1)) {
43472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43473 }
43474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43475 {
43476 PyThreadState* __tstate = wxPyBeginAllowThreads();
43477 result = (bool)(arg1)->IsOwnerDrawn();
43478 wxPyEndAllowThreads(__tstate);
43479 if (PyErr_Occurred()) SWIG_fail;
43480 }
43481 {
43482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43483 }
43484 return resultobj;
43485 fail:
43486 return NULL;
43487 }
43488
43489
43490 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43491 PyObject *resultobj = 0;
43492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43493 bool arg2 = (bool) true ;
43494 void *argp1 = 0 ;
43495 int res1 = 0 ;
43496 bool val2 ;
43497 int ecode2 = 0 ;
43498 PyObject * obj0 = 0 ;
43499 PyObject * obj1 = 0 ;
43500 char * kwnames[] = {
43501 (char *) "self",(char *) "ownerDrawn", NULL
43502 };
43503
43504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43510 if (obj1) {
43511 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43512 if (!SWIG_IsOK(ecode2)) {
43513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43514 }
43515 arg2 = static_cast< bool >(val2);
43516 }
43517 {
43518 PyThreadState* __tstate = wxPyBeginAllowThreads();
43519 (arg1)->SetOwnerDrawn(arg2);
43520 wxPyEndAllowThreads(__tstate);
43521 if (PyErr_Occurred()) SWIG_fail;
43522 }
43523 resultobj = SWIG_Py_Void();
43524 return resultobj;
43525 fail:
43526 return NULL;
43527 }
43528
43529
43530 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43531 PyObject *resultobj = 0;
43532 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43533 void *argp1 = 0 ;
43534 int res1 = 0 ;
43535 PyObject *swig_obj[1] ;
43536
43537 if (!args) SWIG_fail;
43538 swig_obj[0] = args;
43539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43540 if (!SWIG_IsOK(res1)) {
43541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43542 }
43543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43544 {
43545 PyThreadState* __tstate = wxPyBeginAllowThreads();
43546 (arg1)->ResetOwnerDrawn();
43547 wxPyEndAllowThreads(__tstate);
43548 if (PyErr_Occurred()) SWIG_fail;
43549 }
43550 resultobj = SWIG_Py_Void();
43551 return resultobj;
43552 fail:
43553 return NULL;
43554 }
43555
43556
43557 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43558 PyObject *obj;
43559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43560 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43561 return SWIG_Py_Void();
43562 }
43563
43564 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43565 return SWIG_Python_InitShadowInstance(args);
43566 }
43567
43568 SWIGINTERN int ControlNameStr_set(PyObject *) {
43569 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43570 return 1;
43571 }
43572
43573
43574 SWIGINTERN PyObject *ControlNameStr_get(void) {
43575 PyObject *pyobj = 0;
43576
43577 {
43578 #if wxUSE_UNICODE
43579 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43580 #else
43581 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43582 #endif
43583 }
43584 return pyobj;
43585 }
43586
43587
43588 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43589 PyObject *resultobj = 0;
43590 wxWindow *arg1 = (wxWindow *) 0 ;
43591 int arg2 = (int) -1 ;
43592 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43593 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43594 wxSize const &arg4_defvalue = wxDefaultSize ;
43595 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43596 long arg5 = (long) 0 ;
43597 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43598 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43599 wxString const &arg7_defvalue = wxPyControlNameStr ;
43600 wxString *arg7 = (wxString *) &arg7_defvalue ;
43601 wxControl *result = 0 ;
43602 void *argp1 = 0 ;
43603 int res1 = 0 ;
43604 int val2 ;
43605 int ecode2 = 0 ;
43606 wxPoint temp3 ;
43607 wxSize temp4 ;
43608 long val5 ;
43609 int ecode5 = 0 ;
43610 void *argp6 = 0 ;
43611 int res6 = 0 ;
43612 bool temp7 = false ;
43613 PyObject * obj0 = 0 ;
43614 PyObject * obj1 = 0 ;
43615 PyObject * obj2 = 0 ;
43616 PyObject * obj3 = 0 ;
43617 PyObject * obj4 = 0 ;
43618 PyObject * obj5 = 0 ;
43619 PyObject * obj6 = 0 ;
43620 char * kwnames[] = {
43621 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43622 };
43623
43624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43626 if (!SWIG_IsOK(res1)) {
43627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43628 }
43629 arg1 = reinterpret_cast< wxWindow * >(argp1);
43630 if (obj1) {
43631 ecode2 = SWIG_AsVal_int(obj1, &val2);
43632 if (!SWIG_IsOK(ecode2)) {
43633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43634 }
43635 arg2 = static_cast< int >(val2);
43636 }
43637 if (obj2) {
43638 {
43639 arg3 = &temp3;
43640 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43641 }
43642 }
43643 if (obj3) {
43644 {
43645 arg4 = &temp4;
43646 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43647 }
43648 }
43649 if (obj4) {
43650 ecode5 = SWIG_AsVal_long(obj4, &val5);
43651 if (!SWIG_IsOK(ecode5)) {
43652 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43653 }
43654 arg5 = static_cast< long >(val5);
43655 }
43656 if (obj5) {
43657 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43658 if (!SWIG_IsOK(res6)) {
43659 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43660 }
43661 if (!argp6) {
43662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43663 }
43664 arg6 = reinterpret_cast< wxValidator * >(argp6);
43665 }
43666 if (obj6) {
43667 {
43668 arg7 = wxString_in_helper(obj6);
43669 if (arg7 == NULL) SWIG_fail;
43670 temp7 = true;
43671 }
43672 }
43673 {
43674 if (!wxPyCheckForApp()) SWIG_fail;
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43681 {
43682 if (temp7)
43683 delete arg7;
43684 }
43685 return resultobj;
43686 fail:
43687 {
43688 if (temp7)
43689 delete arg7;
43690 }
43691 return NULL;
43692 }
43693
43694
43695 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43696 PyObject *resultobj = 0;
43697 wxControl *result = 0 ;
43698
43699 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43700 {
43701 if (!wxPyCheckForApp()) SWIG_fail;
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 result = (wxControl *)new wxControl();
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43708 return resultobj;
43709 fail:
43710 return NULL;
43711 }
43712
43713
43714 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43715 PyObject *resultobj = 0;
43716 wxControl *arg1 = (wxControl *) 0 ;
43717 wxWindow *arg2 = (wxWindow *) 0 ;
43718 int arg3 = (int) -1 ;
43719 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43720 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43721 wxSize const &arg5_defvalue = wxDefaultSize ;
43722 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43723 long arg6 = (long) 0 ;
43724 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43725 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43726 wxString const &arg8_defvalue = wxPyControlNameStr ;
43727 wxString *arg8 = (wxString *) &arg8_defvalue ;
43728 bool result;
43729 void *argp1 = 0 ;
43730 int res1 = 0 ;
43731 void *argp2 = 0 ;
43732 int res2 = 0 ;
43733 int val3 ;
43734 int ecode3 = 0 ;
43735 wxPoint temp4 ;
43736 wxSize temp5 ;
43737 long val6 ;
43738 int ecode6 = 0 ;
43739 void *argp7 = 0 ;
43740 int res7 = 0 ;
43741 bool temp8 = false ;
43742 PyObject * obj0 = 0 ;
43743 PyObject * obj1 = 0 ;
43744 PyObject * obj2 = 0 ;
43745 PyObject * obj3 = 0 ;
43746 PyObject * obj4 = 0 ;
43747 PyObject * obj5 = 0 ;
43748 PyObject * obj6 = 0 ;
43749 PyObject * obj7 = 0 ;
43750 char * kwnames[] = {
43751 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43752 };
43753
43754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43756 if (!SWIG_IsOK(res1)) {
43757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43758 }
43759 arg1 = reinterpret_cast< wxControl * >(argp1);
43760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43761 if (!SWIG_IsOK(res2)) {
43762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43763 }
43764 arg2 = reinterpret_cast< wxWindow * >(argp2);
43765 if (obj2) {
43766 ecode3 = SWIG_AsVal_int(obj2, &val3);
43767 if (!SWIG_IsOK(ecode3)) {
43768 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43769 }
43770 arg3 = static_cast< int >(val3);
43771 }
43772 if (obj3) {
43773 {
43774 arg4 = &temp4;
43775 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43776 }
43777 }
43778 if (obj4) {
43779 {
43780 arg5 = &temp5;
43781 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43782 }
43783 }
43784 if (obj5) {
43785 ecode6 = SWIG_AsVal_long(obj5, &val6);
43786 if (!SWIG_IsOK(ecode6)) {
43787 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43788 }
43789 arg6 = static_cast< long >(val6);
43790 }
43791 if (obj6) {
43792 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43793 if (!SWIG_IsOK(res7)) {
43794 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43795 }
43796 if (!argp7) {
43797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43798 }
43799 arg7 = reinterpret_cast< wxValidator * >(argp7);
43800 }
43801 if (obj7) {
43802 {
43803 arg8 = wxString_in_helper(obj7);
43804 if (arg8 == NULL) SWIG_fail;
43805 temp8 = true;
43806 }
43807 }
43808 {
43809 PyThreadState* __tstate = wxPyBeginAllowThreads();
43810 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43811 wxPyEndAllowThreads(__tstate);
43812 if (PyErr_Occurred()) SWIG_fail;
43813 }
43814 {
43815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43816 }
43817 {
43818 if (temp8)
43819 delete arg8;
43820 }
43821 return resultobj;
43822 fail:
43823 {
43824 if (temp8)
43825 delete arg8;
43826 }
43827 return NULL;
43828 }
43829
43830
43831 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43832 PyObject *resultobj = 0;
43833 wxControl *arg1 = (wxControl *) 0 ;
43834 wxCommandEvent *arg2 = 0 ;
43835 void *argp1 = 0 ;
43836 int res1 = 0 ;
43837 void *argp2 = 0 ;
43838 int res2 = 0 ;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841 char * kwnames[] = {
43842 (char *) "self",(char *) "event", NULL
43843 };
43844
43845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43847 if (!SWIG_IsOK(res1)) {
43848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43849 }
43850 arg1 = reinterpret_cast< wxControl * >(argp1);
43851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43852 if (!SWIG_IsOK(res2)) {
43853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43854 }
43855 if (!argp2) {
43856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43857 }
43858 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 (arg1)->Command(*arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 resultobj = SWIG_Py_Void();
43866 return resultobj;
43867 fail:
43868 return NULL;
43869 }
43870
43871
43872 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43873 PyObject *resultobj = 0;
43874 wxControl *arg1 = (wxControl *) 0 ;
43875 wxString result;
43876 void *argp1 = 0 ;
43877 int res1 = 0 ;
43878 PyObject *swig_obj[1] ;
43879
43880 if (!args) SWIG_fail;
43881 swig_obj[0] = args;
43882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43883 if (!SWIG_IsOK(res1)) {
43884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43885 }
43886 arg1 = reinterpret_cast< wxControl * >(argp1);
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 result = (arg1)->GetLabel();
43890 wxPyEndAllowThreads(__tstate);
43891 if (PyErr_Occurred()) SWIG_fail;
43892 }
43893 {
43894 #if wxUSE_UNICODE
43895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43896 #else
43897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43898 #endif
43899 }
43900 return resultobj;
43901 fail:
43902 return NULL;
43903 }
43904
43905
43906 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43907 PyObject *resultobj = 0;
43908 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43909 SwigValueWrapper<wxVisualAttributes > result;
43910 int val1 ;
43911 int ecode1 = 0 ;
43912 PyObject * obj0 = 0 ;
43913 char * kwnames[] = {
43914 (char *) "variant", NULL
43915 };
43916
43917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43918 if (obj0) {
43919 ecode1 = SWIG_AsVal_int(obj0, &val1);
43920 if (!SWIG_IsOK(ecode1)) {
43921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43922 }
43923 arg1 = static_cast< wxWindowVariant >(val1);
43924 }
43925 {
43926 if (!wxPyCheckForApp()) SWIG_fail;
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 result = wxControl::GetClassDefaultAttributes(arg1);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43933 return resultobj;
43934 fail:
43935 return NULL;
43936 }
43937
43938
43939 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43940 PyObject *obj;
43941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43942 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43943 return SWIG_Py_Void();
43944 }
43945
43946 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43947 return SWIG_Python_InitShadowInstance(args);
43948 }
43949
43950 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43951 PyObject *resultobj = 0;
43952 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43953 wxString *arg2 = 0 ;
43954 PyObject *arg3 = (PyObject *) NULL ;
43955 int result;
43956 void *argp1 = 0 ;
43957 int res1 = 0 ;
43958 bool temp2 = false ;
43959 PyObject * obj0 = 0 ;
43960 PyObject * obj1 = 0 ;
43961 PyObject * obj2 = 0 ;
43962 char * kwnames[] = {
43963 (char *) "self",(char *) "item",(char *) "clientData", NULL
43964 };
43965
43966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43968 if (!SWIG_IsOK(res1)) {
43969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43970 }
43971 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43972 {
43973 arg2 = wxString_in_helper(obj1);
43974 if (arg2 == NULL) SWIG_fail;
43975 temp2 = true;
43976 }
43977 if (obj2) {
43978 arg3 = obj2;
43979 }
43980 {
43981 PyThreadState* __tstate = wxPyBeginAllowThreads();
43982 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43983 wxPyEndAllowThreads(__tstate);
43984 if (PyErr_Occurred()) SWIG_fail;
43985 }
43986 resultobj = SWIG_From_int(static_cast< int >(result));
43987 {
43988 if (temp2)
43989 delete arg2;
43990 }
43991 return resultobj;
43992 fail:
43993 {
43994 if (temp2)
43995 delete arg2;
43996 }
43997 return NULL;
43998 }
43999
44000
44001 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44002 PyObject *resultobj = 0;
44003 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44004 wxArrayString *arg2 = 0 ;
44005 void *argp1 = 0 ;
44006 int res1 = 0 ;
44007 bool temp2 = false ;
44008 PyObject * obj0 = 0 ;
44009 PyObject * obj1 = 0 ;
44010 char * kwnames[] = {
44011 (char *) "self",(char *) "strings", NULL
44012 };
44013
44014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44016 if (!SWIG_IsOK(res1)) {
44017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44018 }
44019 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44020 {
44021 if (! PySequence_Check(obj1)) {
44022 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44023 SWIG_fail;
44024 }
44025 arg2 = new wxArrayString;
44026 temp2 = true;
44027 int i, len=PySequence_Length(obj1);
44028 for (i=0; i<len; i++) {
44029 PyObject* item = PySequence_GetItem(obj1, i);
44030 wxString* s = wxString_in_helper(item);
44031 if (PyErr_Occurred()) SWIG_fail;
44032 arg2->Add(*s);
44033 delete s;
44034 Py_DECREF(item);
44035 }
44036 }
44037 {
44038 PyThreadState* __tstate = wxPyBeginAllowThreads();
44039 (arg1)->Append((wxArrayString const &)*arg2);
44040 wxPyEndAllowThreads(__tstate);
44041 if (PyErr_Occurred()) SWIG_fail;
44042 }
44043 resultobj = SWIG_Py_Void();
44044 {
44045 if (temp2) delete arg2;
44046 }
44047 return resultobj;
44048 fail:
44049 {
44050 if (temp2) delete arg2;
44051 }
44052 return NULL;
44053 }
44054
44055
44056 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44057 PyObject *resultobj = 0;
44058 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44059 wxString *arg2 = 0 ;
44060 unsigned int arg3 ;
44061 PyObject *arg4 = (PyObject *) NULL ;
44062 int result;
44063 void *argp1 = 0 ;
44064 int res1 = 0 ;
44065 bool temp2 = false ;
44066 unsigned int val3 ;
44067 int ecode3 = 0 ;
44068 PyObject * obj0 = 0 ;
44069 PyObject * obj1 = 0 ;
44070 PyObject * obj2 = 0 ;
44071 PyObject * obj3 = 0 ;
44072 char * kwnames[] = {
44073 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44074 };
44075
44076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44078 if (!SWIG_IsOK(res1)) {
44079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44080 }
44081 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44082 {
44083 arg2 = wxString_in_helper(obj1);
44084 if (arg2 == NULL) SWIG_fail;
44085 temp2 = true;
44086 }
44087 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44088 if (!SWIG_IsOK(ecode3)) {
44089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44090 }
44091 arg3 = static_cast< unsigned int >(val3);
44092 if (obj3) {
44093 arg4 = obj3;
44094 }
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 resultobj = SWIG_From_int(static_cast< int >(result));
44102 {
44103 if (temp2)
44104 delete arg2;
44105 }
44106 return resultobj;
44107 fail:
44108 {
44109 if (temp2)
44110 delete arg2;
44111 }
44112 return NULL;
44113 }
44114
44115
44116 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44117 PyObject *resultobj = 0;
44118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44119 void *argp1 = 0 ;
44120 int res1 = 0 ;
44121 PyObject *swig_obj[1] ;
44122
44123 if (!args) SWIG_fail;
44124 swig_obj[0] = args;
44125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44128 }
44129 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 (arg1)->Clear();
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 resultobj = SWIG_Py_Void();
44137 return resultobj;
44138 fail:
44139 return NULL;
44140 }
44141
44142
44143 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44144 PyObject *resultobj = 0;
44145 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44146 unsigned int arg2 ;
44147 void *argp1 = 0 ;
44148 int res1 = 0 ;
44149 unsigned int val2 ;
44150 int ecode2 = 0 ;
44151 PyObject * obj0 = 0 ;
44152 PyObject * obj1 = 0 ;
44153 char * kwnames[] = {
44154 (char *) "self",(char *) "n", NULL
44155 };
44156
44157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44159 if (!SWIG_IsOK(res1)) {
44160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44161 }
44162 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44163 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44164 if (!SWIG_IsOK(ecode2)) {
44165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44166 }
44167 arg2 = static_cast< unsigned int >(val2);
44168 {
44169 PyThreadState* __tstate = wxPyBeginAllowThreads();
44170 (arg1)->Delete(arg2);
44171 wxPyEndAllowThreads(__tstate);
44172 if (PyErr_Occurred()) SWIG_fail;
44173 }
44174 resultobj = SWIG_Py_Void();
44175 return resultobj;
44176 fail:
44177 return NULL;
44178 }
44179
44180
44181 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44182 PyObject *resultobj = 0;
44183 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44184 unsigned int arg2 ;
44185 PyObject *result = 0 ;
44186 void *argp1 = 0 ;
44187 int res1 = 0 ;
44188 unsigned int val2 ;
44189 int ecode2 = 0 ;
44190 PyObject * obj0 = 0 ;
44191 PyObject * obj1 = 0 ;
44192 char * kwnames[] = {
44193 (char *) "self",(char *) "n", NULL
44194 };
44195
44196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44198 if (!SWIG_IsOK(res1)) {
44199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44200 }
44201 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44202 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44203 if (!SWIG_IsOK(ecode2)) {
44204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44205 }
44206 arg2 = static_cast< unsigned int >(val2);
44207 {
44208 PyThreadState* __tstate = wxPyBeginAllowThreads();
44209 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44210 wxPyEndAllowThreads(__tstate);
44211 if (PyErr_Occurred()) SWIG_fail;
44212 }
44213 resultobj = result;
44214 return resultobj;
44215 fail:
44216 return NULL;
44217 }
44218
44219
44220 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44221 PyObject *resultobj = 0;
44222 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44223 unsigned int arg2 ;
44224 PyObject *arg3 = (PyObject *) 0 ;
44225 void *argp1 = 0 ;
44226 int res1 = 0 ;
44227 unsigned int val2 ;
44228 int ecode2 = 0 ;
44229 PyObject * obj0 = 0 ;
44230 PyObject * obj1 = 0 ;
44231 PyObject * obj2 = 0 ;
44232 char * kwnames[] = {
44233 (char *) "self",(char *) "n",(char *) "clientData", NULL
44234 };
44235
44236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44238 if (!SWIG_IsOK(res1)) {
44239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44240 }
44241 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44242 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44243 if (!SWIG_IsOK(ecode2)) {
44244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44245 }
44246 arg2 = static_cast< unsigned int >(val2);
44247 arg3 = obj2;
44248 {
44249 PyThreadState* __tstate = wxPyBeginAllowThreads();
44250 wxItemContainer_SetClientData(arg1,arg2,arg3);
44251 wxPyEndAllowThreads(__tstate);
44252 if (PyErr_Occurred()) SWIG_fail;
44253 }
44254 resultobj = SWIG_Py_Void();
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44262 PyObject *resultobj = 0;
44263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44264 unsigned int result;
44265 void *argp1 = 0 ;
44266 int res1 = 0 ;
44267 PyObject *swig_obj[1] ;
44268
44269 if (!args) SWIG_fail;
44270 swig_obj[0] = args;
44271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44272 if (!SWIG_IsOK(res1)) {
44273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44274 }
44275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44276 {
44277 PyThreadState* __tstate = wxPyBeginAllowThreads();
44278 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44279 wxPyEndAllowThreads(__tstate);
44280 if (PyErr_Occurred()) SWIG_fail;
44281 }
44282 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44283 return resultobj;
44284 fail:
44285 return NULL;
44286 }
44287
44288
44289 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44290 PyObject *resultobj = 0;
44291 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44292 bool result;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 PyObject *swig_obj[1] ;
44296
44297 if (!args) SWIG_fail;
44298 swig_obj[0] = args;
44299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44300 if (!SWIG_IsOK(res1)) {
44301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44302 }
44303 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44307 wxPyEndAllowThreads(__tstate);
44308 if (PyErr_Occurred()) SWIG_fail;
44309 }
44310 {
44311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44312 }
44313 return resultobj;
44314 fail:
44315 return NULL;
44316 }
44317
44318
44319 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44320 PyObject *resultobj = 0;
44321 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44322 unsigned int arg2 ;
44323 wxString result;
44324 void *argp1 = 0 ;
44325 int res1 = 0 ;
44326 unsigned int val2 ;
44327 int ecode2 = 0 ;
44328 PyObject * obj0 = 0 ;
44329 PyObject * obj1 = 0 ;
44330 char * kwnames[] = {
44331 (char *) "self",(char *) "n", NULL
44332 };
44333
44334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44336 if (!SWIG_IsOK(res1)) {
44337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44338 }
44339 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44340 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44341 if (!SWIG_IsOK(ecode2)) {
44342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44343 }
44344 arg2 = static_cast< unsigned int >(val2);
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 {
44352 #if wxUSE_UNICODE
44353 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44354 #else
44355 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44356 #endif
44357 }
44358 return resultobj;
44359 fail:
44360 return NULL;
44361 }
44362
44363
44364 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44365 PyObject *resultobj = 0;
44366 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44367 wxArrayString result;
44368 void *argp1 = 0 ;
44369 int res1 = 0 ;
44370 PyObject *swig_obj[1] ;
44371
44372 if (!args) SWIG_fail;
44373 swig_obj[0] = args;
44374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44375 if (!SWIG_IsOK(res1)) {
44376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44377 }
44378 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44379 {
44380 PyThreadState* __tstate = wxPyBeginAllowThreads();
44381 result = ((wxItemContainer const *)arg1)->GetStrings();
44382 wxPyEndAllowThreads(__tstate);
44383 if (PyErr_Occurred()) SWIG_fail;
44384 }
44385 {
44386 resultobj = wxArrayString2PyList_helper(result);
44387 }
44388 return resultobj;
44389 fail:
44390 return NULL;
44391 }
44392
44393
44394 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44395 PyObject *resultobj = 0;
44396 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44397 unsigned int arg2 ;
44398 wxString *arg3 = 0 ;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 unsigned int val2 ;
44402 int ecode2 = 0 ;
44403 bool temp3 = false ;
44404 PyObject * obj0 = 0 ;
44405 PyObject * obj1 = 0 ;
44406 PyObject * obj2 = 0 ;
44407 char * kwnames[] = {
44408 (char *) "self",(char *) "n",(char *) "s", NULL
44409 };
44410
44411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44413 if (!SWIG_IsOK(res1)) {
44414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44415 }
44416 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44417 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44418 if (!SWIG_IsOK(ecode2)) {
44419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44420 }
44421 arg2 = static_cast< unsigned int >(val2);
44422 {
44423 arg3 = wxString_in_helper(obj2);
44424 if (arg3 == NULL) SWIG_fail;
44425 temp3 = true;
44426 }
44427 {
44428 PyThreadState* __tstate = wxPyBeginAllowThreads();
44429 (arg1)->SetString(arg2,(wxString const &)*arg3);
44430 wxPyEndAllowThreads(__tstate);
44431 if (PyErr_Occurred()) SWIG_fail;
44432 }
44433 resultobj = SWIG_Py_Void();
44434 {
44435 if (temp3)
44436 delete arg3;
44437 }
44438 return resultobj;
44439 fail:
44440 {
44441 if (temp3)
44442 delete arg3;
44443 }
44444 return NULL;
44445 }
44446
44447
44448 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44449 PyObject *resultobj = 0;
44450 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44451 wxString *arg2 = 0 ;
44452 int result;
44453 void *argp1 = 0 ;
44454 int res1 = 0 ;
44455 bool temp2 = false ;
44456 PyObject * obj0 = 0 ;
44457 PyObject * obj1 = 0 ;
44458 char * kwnames[] = {
44459 (char *) "self",(char *) "s", NULL
44460 };
44461
44462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44464 if (!SWIG_IsOK(res1)) {
44465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44466 }
44467 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44468 {
44469 arg2 = wxString_in_helper(obj1);
44470 if (arg2 == NULL) SWIG_fail;
44471 temp2 = true;
44472 }
44473 {
44474 PyThreadState* __tstate = wxPyBeginAllowThreads();
44475 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44476 wxPyEndAllowThreads(__tstate);
44477 if (PyErr_Occurred()) SWIG_fail;
44478 }
44479 resultobj = SWIG_From_int(static_cast< int >(result));
44480 {
44481 if (temp2)
44482 delete arg2;
44483 }
44484 return resultobj;
44485 fail:
44486 {
44487 if (temp2)
44488 delete arg2;
44489 }
44490 return NULL;
44491 }
44492
44493
44494 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44495 PyObject *resultobj = 0;
44496 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44497 int arg2 ;
44498 void *argp1 = 0 ;
44499 int res1 = 0 ;
44500 int val2 ;
44501 int ecode2 = 0 ;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 char * kwnames[] = {
44505 (char *) "self",(char *) "n", NULL
44506 };
44507
44508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44510 if (!SWIG_IsOK(res1)) {
44511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44512 }
44513 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44514 ecode2 = SWIG_AsVal_int(obj1, &val2);
44515 if (!SWIG_IsOK(ecode2)) {
44516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44517 }
44518 arg2 = static_cast< int >(val2);
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 (arg1)->SetSelection(arg2);
44522 wxPyEndAllowThreads(__tstate);
44523 if (PyErr_Occurred()) SWIG_fail;
44524 }
44525 resultobj = SWIG_Py_Void();
44526 return resultobj;
44527 fail:
44528 return NULL;
44529 }
44530
44531
44532 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44533 PyObject *resultobj = 0;
44534 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44535 int result;
44536 void *argp1 = 0 ;
44537 int res1 = 0 ;
44538 PyObject *swig_obj[1] ;
44539
44540 if (!args) SWIG_fail;
44541 swig_obj[0] = args;
44542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44543 if (!SWIG_IsOK(res1)) {
44544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44545 }
44546 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44547 {
44548 PyThreadState* __tstate = wxPyBeginAllowThreads();
44549 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44550 wxPyEndAllowThreads(__tstate);
44551 if (PyErr_Occurred()) SWIG_fail;
44552 }
44553 resultobj = SWIG_From_int(static_cast< int >(result));
44554 return resultobj;
44555 fail:
44556 return NULL;
44557 }
44558
44559
44560 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44561 PyObject *resultobj = 0;
44562 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44563 wxString *arg2 = 0 ;
44564 bool result;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 bool temp2 = false ;
44568 PyObject * obj0 = 0 ;
44569 PyObject * obj1 = 0 ;
44570 char * kwnames[] = {
44571 (char *) "self",(char *) "s", NULL
44572 };
44573
44574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44576 if (!SWIG_IsOK(res1)) {
44577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44578 }
44579 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44580 {
44581 arg2 = wxString_in_helper(obj1);
44582 if (arg2 == NULL) SWIG_fail;
44583 temp2 = true;
44584 }
44585 {
44586 PyThreadState* __tstate = wxPyBeginAllowThreads();
44587 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44588 wxPyEndAllowThreads(__tstate);
44589 if (PyErr_Occurred()) SWIG_fail;
44590 }
44591 {
44592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44593 }
44594 {
44595 if (temp2)
44596 delete arg2;
44597 }
44598 return resultobj;
44599 fail:
44600 {
44601 if (temp2)
44602 delete arg2;
44603 }
44604 return NULL;
44605 }
44606
44607
44608 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44609 PyObject *resultobj = 0;
44610 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44611 wxString result;
44612 void *argp1 = 0 ;
44613 int res1 = 0 ;
44614 PyObject *swig_obj[1] ;
44615
44616 if (!args) SWIG_fail;
44617 swig_obj[0] = args;
44618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44619 if (!SWIG_IsOK(res1)) {
44620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44621 }
44622 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44623 {
44624 PyThreadState* __tstate = wxPyBeginAllowThreads();
44625 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44626 wxPyEndAllowThreads(__tstate);
44627 if (PyErr_Occurred()) SWIG_fail;
44628 }
44629 {
44630 #if wxUSE_UNICODE
44631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44632 #else
44633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44634 #endif
44635 }
44636 return resultobj;
44637 fail:
44638 return NULL;
44639 }
44640
44641
44642 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44643 PyObject *resultobj = 0;
44644 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44645 int arg2 ;
44646 void *argp1 = 0 ;
44647 int res1 = 0 ;
44648 int val2 ;
44649 int ecode2 = 0 ;
44650 PyObject * obj0 = 0 ;
44651 PyObject * obj1 = 0 ;
44652 char * kwnames[] = {
44653 (char *) "self",(char *) "n", NULL
44654 };
44655
44656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44658 if (!SWIG_IsOK(res1)) {
44659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44660 }
44661 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44662 ecode2 = SWIG_AsVal_int(obj1, &val2);
44663 if (!SWIG_IsOK(ecode2)) {
44664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44665 }
44666 arg2 = static_cast< int >(val2);
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 (arg1)->Select(arg2);
44670 wxPyEndAllowThreads(__tstate);
44671 if (PyErr_Occurred()) SWIG_fail;
44672 }
44673 resultobj = SWIG_Py_Void();
44674 return resultobj;
44675 fail:
44676 return NULL;
44677 }
44678
44679
44680 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44681 PyObject *obj;
44682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44683 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44684 return SWIG_Py_Void();
44685 }
44686
44687 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44688 PyObject *obj;
44689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44690 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44691 return SWIG_Py_Void();
44692 }
44693
44694 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44695 PyObject *resultobj = 0;
44696 wxSizerItem *result = 0 ;
44697
44698 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44699 {
44700 PyThreadState* __tstate = wxPyBeginAllowThreads();
44701 result = (wxSizerItem *)new wxSizerItem();
44702 wxPyEndAllowThreads(__tstate);
44703 if (PyErr_Occurred()) SWIG_fail;
44704 }
44705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44706 return resultobj;
44707 fail:
44708 return NULL;
44709 }
44710
44711
44712 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44713 PyObject *resultobj = 0;
44714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44715 void *argp1 = 0 ;
44716 int res1 = 0 ;
44717 PyObject *swig_obj[1] ;
44718
44719 if (!args) SWIG_fail;
44720 swig_obj[0] = args;
44721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44722 if (!SWIG_IsOK(res1)) {
44723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44724 }
44725 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44726 {
44727 PyThreadState* __tstate = wxPyBeginAllowThreads();
44728 delete arg1;
44729
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 resultobj = SWIG_Py_Void();
44734 return resultobj;
44735 fail:
44736 return NULL;
44737 }
44738
44739
44740 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44741 PyObject *resultobj = 0;
44742 wxWindow *arg1 = (wxWindow *) 0 ;
44743 int arg2 ;
44744 int arg3 ;
44745 int arg4 ;
44746 PyObject *arg5 = (PyObject *) NULL ;
44747 wxSizerItem *result = 0 ;
44748 void *argp1 = 0 ;
44749 int res1 = 0 ;
44750 int val2 ;
44751 int ecode2 = 0 ;
44752 int val3 ;
44753 int ecode3 = 0 ;
44754 int val4 ;
44755 int ecode4 = 0 ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 PyObject * obj2 = 0 ;
44759 PyObject * obj3 = 0 ;
44760 PyObject * obj4 = 0 ;
44761 char * kwnames[] = {
44762 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44763 };
44764
44765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44767 if (!SWIG_IsOK(res1)) {
44768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44769 }
44770 arg1 = reinterpret_cast< wxWindow * >(argp1);
44771 ecode2 = SWIG_AsVal_int(obj1, &val2);
44772 if (!SWIG_IsOK(ecode2)) {
44773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44774 }
44775 arg2 = static_cast< int >(val2);
44776 ecode3 = SWIG_AsVal_int(obj2, &val3);
44777 if (!SWIG_IsOK(ecode3)) {
44778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44779 }
44780 arg3 = static_cast< int >(val3);
44781 ecode4 = SWIG_AsVal_int(obj3, &val4);
44782 if (!SWIG_IsOK(ecode4)) {
44783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44784 }
44785 arg4 = static_cast< int >(val4);
44786 if (obj4) {
44787 arg5 = obj4;
44788 }
44789 {
44790 PyThreadState* __tstate = wxPyBeginAllowThreads();
44791 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44792 wxPyEndAllowThreads(__tstate);
44793 if (PyErr_Occurred()) SWIG_fail;
44794 }
44795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44796 return resultobj;
44797 fail:
44798 return NULL;
44799 }
44800
44801
44802 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44803 PyObject *resultobj = 0;
44804 int arg1 ;
44805 int arg2 ;
44806 int arg3 ;
44807 int arg4 ;
44808 int arg5 ;
44809 PyObject *arg6 = (PyObject *) NULL ;
44810 wxSizerItem *result = 0 ;
44811 int val1 ;
44812 int ecode1 = 0 ;
44813 int val2 ;
44814 int ecode2 = 0 ;
44815 int val3 ;
44816 int ecode3 = 0 ;
44817 int val4 ;
44818 int ecode4 = 0 ;
44819 int val5 ;
44820 int ecode5 = 0 ;
44821 PyObject * obj0 = 0 ;
44822 PyObject * obj1 = 0 ;
44823 PyObject * obj2 = 0 ;
44824 PyObject * obj3 = 0 ;
44825 PyObject * obj4 = 0 ;
44826 PyObject * obj5 = 0 ;
44827 char * kwnames[] = {
44828 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44829 };
44830
44831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44832 ecode1 = SWIG_AsVal_int(obj0, &val1);
44833 if (!SWIG_IsOK(ecode1)) {
44834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44835 }
44836 arg1 = static_cast< int >(val1);
44837 ecode2 = SWIG_AsVal_int(obj1, &val2);
44838 if (!SWIG_IsOK(ecode2)) {
44839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44840 }
44841 arg2 = static_cast< int >(val2);
44842 ecode3 = SWIG_AsVal_int(obj2, &val3);
44843 if (!SWIG_IsOK(ecode3)) {
44844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44845 }
44846 arg3 = static_cast< int >(val3);
44847 ecode4 = SWIG_AsVal_int(obj3, &val4);
44848 if (!SWIG_IsOK(ecode4)) {
44849 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44850 }
44851 arg4 = static_cast< int >(val4);
44852 ecode5 = SWIG_AsVal_int(obj4, &val5);
44853 if (!SWIG_IsOK(ecode5)) {
44854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44855 }
44856 arg5 = static_cast< int >(val5);
44857 if (obj5) {
44858 arg6 = obj5;
44859 }
44860 {
44861 PyThreadState* __tstate = wxPyBeginAllowThreads();
44862 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44863 wxPyEndAllowThreads(__tstate);
44864 if (PyErr_Occurred()) SWIG_fail;
44865 }
44866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44867 return resultobj;
44868 fail:
44869 return NULL;
44870 }
44871
44872
44873 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44874 PyObject *resultobj = 0;
44875 wxSizer *arg1 = (wxSizer *) 0 ;
44876 int arg2 ;
44877 int arg3 ;
44878 int arg4 ;
44879 PyObject *arg5 = (PyObject *) NULL ;
44880 wxSizerItem *result = 0 ;
44881 int res1 = 0 ;
44882 int val2 ;
44883 int ecode2 = 0 ;
44884 int val3 ;
44885 int ecode3 = 0 ;
44886 int val4 ;
44887 int ecode4 = 0 ;
44888 PyObject * obj0 = 0 ;
44889 PyObject * obj1 = 0 ;
44890 PyObject * obj2 = 0 ;
44891 PyObject * obj3 = 0 ;
44892 PyObject * obj4 = 0 ;
44893 char * kwnames[] = {
44894 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44895 };
44896
44897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44898 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44899 if (!SWIG_IsOK(res1)) {
44900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44901 }
44902 ecode2 = SWIG_AsVal_int(obj1, &val2);
44903 if (!SWIG_IsOK(ecode2)) {
44904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44905 }
44906 arg2 = static_cast< int >(val2);
44907 ecode3 = SWIG_AsVal_int(obj2, &val3);
44908 if (!SWIG_IsOK(ecode3)) {
44909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44910 }
44911 arg3 = static_cast< int >(val3);
44912 ecode4 = SWIG_AsVal_int(obj3, &val4);
44913 if (!SWIG_IsOK(ecode4)) {
44914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44915 }
44916 arg4 = static_cast< int >(val4);
44917 if (obj4) {
44918 arg5 = obj4;
44919 }
44920 {
44921 PyThreadState* __tstate = wxPyBeginAllowThreads();
44922 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44923 wxPyEndAllowThreads(__tstate);
44924 if (PyErr_Occurred()) SWIG_fail;
44925 }
44926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44927 return resultobj;
44928 fail:
44929 return NULL;
44930 }
44931
44932
44933 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 PyObject *resultobj = 0;
44935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44936 void *argp1 = 0 ;
44937 int res1 = 0 ;
44938 PyObject *swig_obj[1] ;
44939
44940 if (!args) SWIG_fail;
44941 swig_obj[0] = args;
44942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44943 if (!SWIG_IsOK(res1)) {
44944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44945 }
44946 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44947 {
44948 PyThreadState* __tstate = wxPyBeginAllowThreads();
44949 (arg1)->DeleteWindows();
44950 wxPyEndAllowThreads(__tstate);
44951 if (PyErr_Occurred()) SWIG_fail;
44952 }
44953 resultobj = SWIG_Py_Void();
44954 return resultobj;
44955 fail:
44956 return NULL;
44957 }
44958
44959
44960 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44961 PyObject *resultobj = 0;
44962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44963 void *argp1 = 0 ;
44964 int res1 = 0 ;
44965 PyObject *swig_obj[1] ;
44966
44967 if (!args) SWIG_fail;
44968 swig_obj[0] = args;
44969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44970 if (!SWIG_IsOK(res1)) {
44971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44972 }
44973 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44974 {
44975 PyThreadState* __tstate = wxPyBeginAllowThreads();
44976 (arg1)->DetachSizer();
44977 wxPyEndAllowThreads(__tstate);
44978 if (PyErr_Occurred()) SWIG_fail;
44979 }
44980 resultobj = SWIG_Py_Void();
44981 return resultobj;
44982 fail:
44983 return NULL;
44984 }
44985
44986
44987 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44988 PyObject *resultobj = 0;
44989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44990 wxSize result;
44991 void *argp1 = 0 ;
44992 int res1 = 0 ;
44993 PyObject *swig_obj[1] ;
44994
44995 if (!args) SWIG_fail;
44996 swig_obj[0] = args;
44997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44998 if (!SWIG_IsOK(res1)) {
44999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45000 }
45001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45002 {
45003 PyThreadState* __tstate = wxPyBeginAllowThreads();
45004 result = (arg1)->GetSize();
45005 wxPyEndAllowThreads(__tstate);
45006 if (PyErr_Occurred()) SWIG_fail;
45007 }
45008 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45009 return resultobj;
45010 fail:
45011 return NULL;
45012 }
45013
45014
45015 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45016 PyObject *resultobj = 0;
45017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45018 wxSize result;
45019 void *argp1 = 0 ;
45020 int res1 = 0 ;
45021 PyObject *swig_obj[1] ;
45022
45023 if (!args) SWIG_fail;
45024 swig_obj[0] = args;
45025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45026 if (!SWIG_IsOK(res1)) {
45027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45028 }
45029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 result = (arg1)->CalcMin();
45033 wxPyEndAllowThreads(__tstate);
45034 if (PyErr_Occurred()) SWIG_fail;
45035 }
45036 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45044 PyObject *resultobj = 0;
45045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45046 wxPoint *arg2 = 0 ;
45047 wxSize *arg3 = 0 ;
45048 void *argp1 = 0 ;
45049 int res1 = 0 ;
45050 wxPoint temp2 ;
45051 wxSize temp3 ;
45052 PyObject * obj0 = 0 ;
45053 PyObject * obj1 = 0 ;
45054 PyObject * obj2 = 0 ;
45055 char * kwnames[] = {
45056 (char *) "self",(char *) "pos",(char *) "size", NULL
45057 };
45058
45059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45061 if (!SWIG_IsOK(res1)) {
45062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45063 }
45064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45065 {
45066 arg2 = &temp2;
45067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45068 }
45069 {
45070 arg3 = &temp3;
45071 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45072 }
45073 {
45074 PyThreadState* __tstate = wxPyBeginAllowThreads();
45075 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45076 wxPyEndAllowThreads(__tstate);
45077 if (PyErr_Occurred()) SWIG_fail;
45078 }
45079 resultobj = SWIG_Py_Void();
45080 return resultobj;
45081 fail:
45082 return NULL;
45083 }
45084
45085
45086 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45087 PyObject *resultobj = 0;
45088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45089 wxSize result;
45090 void *argp1 = 0 ;
45091 int res1 = 0 ;
45092 PyObject *swig_obj[1] ;
45093
45094 if (!args) SWIG_fail;
45095 swig_obj[0] = args;
45096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45097 if (!SWIG_IsOK(res1)) {
45098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45099 }
45100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45101 {
45102 PyThreadState* __tstate = wxPyBeginAllowThreads();
45103 result = (arg1)->GetMinSize();
45104 wxPyEndAllowThreads(__tstate);
45105 if (PyErr_Occurred()) SWIG_fail;
45106 }
45107 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45108 return resultobj;
45109 fail:
45110 return NULL;
45111 }
45112
45113
45114 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45115 PyObject *resultobj = 0;
45116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45117 wxSize result;
45118 void *argp1 = 0 ;
45119 int res1 = 0 ;
45120 PyObject *swig_obj[1] ;
45121
45122 if (!args) SWIG_fail;
45123 swig_obj[0] = args;
45124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45125 if (!SWIG_IsOK(res1)) {
45126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45127 }
45128 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45129 {
45130 PyThreadState* __tstate = wxPyBeginAllowThreads();
45131 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45132 wxPyEndAllowThreads(__tstate);
45133 if (PyErr_Occurred()) SWIG_fail;
45134 }
45135 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45136 return resultobj;
45137 fail:
45138 return NULL;
45139 }
45140
45141
45142 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45143 PyObject *resultobj = 0;
45144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45145 int arg2 ;
45146 int arg3 ;
45147 void *argp1 = 0 ;
45148 int res1 = 0 ;
45149 int val2 ;
45150 int ecode2 = 0 ;
45151 int val3 ;
45152 int ecode3 = 0 ;
45153 PyObject * obj0 = 0 ;
45154 PyObject * obj1 = 0 ;
45155 PyObject * obj2 = 0 ;
45156 char * kwnames[] = {
45157 (char *) "self",(char *) "x",(char *) "y", NULL
45158 };
45159
45160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45162 if (!SWIG_IsOK(res1)) {
45163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45164 }
45165 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45166 ecode2 = SWIG_AsVal_int(obj1, &val2);
45167 if (!SWIG_IsOK(ecode2)) {
45168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45169 }
45170 arg2 = static_cast< int >(val2);
45171 ecode3 = SWIG_AsVal_int(obj2, &val3);
45172 if (!SWIG_IsOK(ecode3)) {
45173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45174 }
45175 arg3 = static_cast< int >(val3);
45176 {
45177 PyThreadState* __tstate = wxPyBeginAllowThreads();
45178 (arg1)->SetInitSize(arg2,arg3);
45179 wxPyEndAllowThreads(__tstate);
45180 if (PyErr_Occurred()) SWIG_fail;
45181 }
45182 resultobj = SWIG_Py_Void();
45183 return resultobj;
45184 fail:
45185 return NULL;
45186 }
45187
45188
45189 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45190 PyObject *resultobj = 0;
45191 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45192 int arg2 ;
45193 int arg3 ;
45194 void *argp1 = 0 ;
45195 int res1 = 0 ;
45196 int val2 ;
45197 int ecode2 = 0 ;
45198 int val3 ;
45199 int ecode3 = 0 ;
45200 PyObject * obj0 = 0 ;
45201 PyObject * obj1 = 0 ;
45202 PyObject * obj2 = 0 ;
45203 char * kwnames[] = {
45204 (char *) "self",(char *) "width",(char *) "height", NULL
45205 };
45206
45207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45209 if (!SWIG_IsOK(res1)) {
45210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45211 }
45212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45213 ecode2 = SWIG_AsVal_int(obj1, &val2);
45214 if (!SWIG_IsOK(ecode2)) {
45215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45216 }
45217 arg2 = static_cast< int >(val2);
45218 ecode3 = SWIG_AsVal_int(obj2, &val3);
45219 if (!SWIG_IsOK(ecode3)) {
45220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45221 }
45222 arg3 = static_cast< int >(val3);
45223 {
45224 PyThreadState* __tstate = wxPyBeginAllowThreads();
45225 (arg1)->SetRatio(arg2,arg3);
45226 wxPyEndAllowThreads(__tstate);
45227 if (PyErr_Occurred()) SWIG_fail;
45228 }
45229 resultobj = SWIG_Py_Void();
45230 return resultobj;
45231 fail:
45232 return NULL;
45233 }
45234
45235
45236 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45237 PyObject *resultobj = 0;
45238 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45239 wxSize *arg2 = 0 ;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 wxSize temp2 ;
45243 PyObject * obj0 = 0 ;
45244 PyObject * obj1 = 0 ;
45245 char * kwnames[] = {
45246 (char *) "self",(char *) "size", NULL
45247 };
45248
45249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45251 if (!SWIG_IsOK(res1)) {
45252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45253 }
45254 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45255 {
45256 arg2 = &temp2;
45257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45258 }
45259 {
45260 PyThreadState* __tstate = wxPyBeginAllowThreads();
45261 (arg1)->SetRatio((wxSize const &)*arg2);
45262 wxPyEndAllowThreads(__tstate);
45263 if (PyErr_Occurred()) SWIG_fail;
45264 }
45265 resultobj = SWIG_Py_Void();
45266 return resultobj;
45267 fail:
45268 return NULL;
45269 }
45270
45271
45272 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45273 PyObject *resultobj = 0;
45274 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45275 float arg2 ;
45276 void *argp1 = 0 ;
45277 int res1 = 0 ;
45278 float val2 ;
45279 int ecode2 = 0 ;
45280 PyObject * obj0 = 0 ;
45281 PyObject * obj1 = 0 ;
45282 char * kwnames[] = {
45283 (char *) "self",(char *) "ratio", NULL
45284 };
45285
45286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45288 if (!SWIG_IsOK(res1)) {
45289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45290 }
45291 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45292 ecode2 = SWIG_AsVal_float(obj1, &val2);
45293 if (!SWIG_IsOK(ecode2)) {
45294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45295 }
45296 arg2 = static_cast< float >(val2);
45297 {
45298 PyThreadState* __tstate = wxPyBeginAllowThreads();
45299 (arg1)->SetRatio(arg2);
45300 wxPyEndAllowThreads(__tstate);
45301 if (PyErr_Occurred()) SWIG_fail;
45302 }
45303 resultobj = SWIG_Py_Void();
45304 return resultobj;
45305 fail:
45306 return NULL;
45307 }
45308
45309
45310 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45311 PyObject *resultobj = 0;
45312 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45313 float result;
45314 void *argp1 = 0 ;
45315 int res1 = 0 ;
45316 PyObject *swig_obj[1] ;
45317
45318 if (!args) SWIG_fail;
45319 swig_obj[0] = args;
45320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45321 if (!SWIG_IsOK(res1)) {
45322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45323 }
45324 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 result = (float)(arg1)->GetRatio();
45328 wxPyEndAllowThreads(__tstate);
45329 if (PyErr_Occurred()) SWIG_fail;
45330 }
45331 resultobj = SWIG_From_float(static_cast< float >(result));
45332 return resultobj;
45333 fail:
45334 return NULL;
45335 }
45336
45337
45338 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45339 PyObject *resultobj = 0;
45340 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45341 wxRect result;
45342 void *argp1 = 0 ;
45343 int res1 = 0 ;
45344 PyObject *swig_obj[1] ;
45345
45346 if (!args) SWIG_fail;
45347 swig_obj[0] = args;
45348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45351 }
45352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45353 {
45354 PyThreadState* __tstate = wxPyBeginAllowThreads();
45355 result = (arg1)->GetRect();
45356 wxPyEndAllowThreads(__tstate);
45357 if (PyErr_Occurred()) SWIG_fail;
45358 }
45359 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45360 return resultobj;
45361 fail:
45362 return NULL;
45363 }
45364
45365
45366 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45367 PyObject *resultobj = 0;
45368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45369 bool result;
45370 void *argp1 = 0 ;
45371 int res1 = 0 ;
45372 PyObject *swig_obj[1] ;
45373
45374 if (!args) SWIG_fail;
45375 swig_obj[0] = args;
45376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45377 if (!SWIG_IsOK(res1)) {
45378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45379 }
45380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45381 {
45382 PyThreadState* __tstate = wxPyBeginAllowThreads();
45383 result = (bool)(arg1)->IsWindow();
45384 wxPyEndAllowThreads(__tstate);
45385 if (PyErr_Occurred()) SWIG_fail;
45386 }
45387 {
45388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45389 }
45390 return resultobj;
45391 fail:
45392 return NULL;
45393 }
45394
45395
45396 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45397 PyObject *resultobj = 0;
45398 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45399 bool result;
45400 void *argp1 = 0 ;
45401 int res1 = 0 ;
45402 PyObject *swig_obj[1] ;
45403
45404 if (!args) SWIG_fail;
45405 swig_obj[0] = args;
45406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45407 if (!SWIG_IsOK(res1)) {
45408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45409 }
45410 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45411 {
45412 PyThreadState* __tstate = wxPyBeginAllowThreads();
45413 result = (bool)(arg1)->IsSizer();
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 {
45418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45419 }
45420 return resultobj;
45421 fail:
45422 return NULL;
45423 }
45424
45425
45426 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45427 PyObject *resultobj = 0;
45428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45429 bool result;
45430 void *argp1 = 0 ;
45431 int res1 = 0 ;
45432 PyObject *swig_obj[1] ;
45433
45434 if (!args) SWIG_fail;
45435 swig_obj[0] = args;
45436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45437 if (!SWIG_IsOK(res1)) {
45438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45439 }
45440 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45441 {
45442 PyThreadState* __tstate = wxPyBeginAllowThreads();
45443 result = (bool)(arg1)->IsSpacer();
45444 wxPyEndAllowThreads(__tstate);
45445 if (PyErr_Occurred()) SWIG_fail;
45446 }
45447 {
45448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45449 }
45450 return resultobj;
45451 fail:
45452 return NULL;
45453 }
45454
45455
45456 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45457 PyObject *resultobj = 0;
45458 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45459 int arg2 ;
45460 void *argp1 = 0 ;
45461 int res1 = 0 ;
45462 int val2 ;
45463 int ecode2 = 0 ;
45464 PyObject * obj0 = 0 ;
45465 PyObject * obj1 = 0 ;
45466 char * kwnames[] = {
45467 (char *) "self",(char *) "proportion", NULL
45468 };
45469
45470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45472 if (!SWIG_IsOK(res1)) {
45473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45474 }
45475 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45476 ecode2 = SWIG_AsVal_int(obj1, &val2);
45477 if (!SWIG_IsOK(ecode2)) {
45478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45479 }
45480 arg2 = static_cast< int >(val2);
45481 {
45482 PyThreadState* __tstate = wxPyBeginAllowThreads();
45483 (arg1)->SetProportion(arg2);
45484 wxPyEndAllowThreads(__tstate);
45485 if (PyErr_Occurred()) SWIG_fail;
45486 }
45487 resultobj = SWIG_Py_Void();
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45495 PyObject *resultobj = 0;
45496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45497 int result;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 PyObject *swig_obj[1] ;
45501
45502 if (!args) SWIG_fail;
45503 swig_obj[0] = args;
45504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45505 if (!SWIG_IsOK(res1)) {
45506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45507 }
45508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 result = (int)(arg1)->GetProportion();
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 resultobj = SWIG_From_int(static_cast< int >(result));
45516 return resultobj;
45517 fail:
45518 return NULL;
45519 }
45520
45521
45522 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45523 PyObject *resultobj = 0;
45524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45525 int arg2 ;
45526 void *argp1 = 0 ;
45527 int res1 = 0 ;
45528 int val2 ;
45529 int ecode2 = 0 ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 char * kwnames[] = {
45533 (char *) "self",(char *) "flag", NULL
45534 };
45535
45536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45538 if (!SWIG_IsOK(res1)) {
45539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45540 }
45541 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45542 ecode2 = SWIG_AsVal_int(obj1, &val2);
45543 if (!SWIG_IsOK(ecode2)) {
45544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45545 }
45546 arg2 = static_cast< int >(val2);
45547 {
45548 PyThreadState* __tstate = wxPyBeginAllowThreads();
45549 (arg1)->SetFlag(arg2);
45550 wxPyEndAllowThreads(__tstate);
45551 if (PyErr_Occurred()) SWIG_fail;
45552 }
45553 resultobj = SWIG_Py_Void();
45554 return resultobj;
45555 fail:
45556 return NULL;
45557 }
45558
45559
45560 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45561 PyObject *resultobj = 0;
45562 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45563 int result;
45564 void *argp1 = 0 ;
45565 int res1 = 0 ;
45566 PyObject *swig_obj[1] ;
45567
45568 if (!args) SWIG_fail;
45569 swig_obj[0] = args;
45570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45571 if (!SWIG_IsOK(res1)) {
45572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45573 }
45574 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45575 {
45576 PyThreadState* __tstate = wxPyBeginAllowThreads();
45577 result = (int)(arg1)->GetFlag();
45578 wxPyEndAllowThreads(__tstate);
45579 if (PyErr_Occurred()) SWIG_fail;
45580 }
45581 resultobj = SWIG_From_int(static_cast< int >(result));
45582 return resultobj;
45583 fail:
45584 return NULL;
45585 }
45586
45587
45588 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45589 PyObject *resultobj = 0;
45590 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45591 int arg2 ;
45592 void *argp1 = 0 ;
45593 int res1 = 0 ;
45594 int val2 ;
45595 int ecode2 = 0 ;
45596 PyObject * obj0 = 0 ;
45597 PyObject * obj1 = 0 ;
45598 char * kwnames[] = {
45599 (char *) "self",(char *) "border", NULL
45600 };
45601
45602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45604 if (!SWIG_IsOK(res1)) {
45605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45606 }
45607 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45608 ecode2 = SWIG_AsVal_int(obj1, &val2);
45609 if (!SWIG_IsOK(ecode2)) {
45610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45611 }
45612 arg2 = static_cast< int >(val2);
45613 {
45614 PyThreadState* __tstate = wxPyBeginAllowThreads();
45615 (arg1)->SetBorder(arg2);
45616 wxPyEndAllowThreads(__tstate);
45617 if (PyErr_Occurred()) SWIG_fail;
45618 }
45619 resultobj = SWIG_Py_Void();
45620 return resultobj;
45621 fail:
45622 return NULL;
45623 }
45624
45625
45626 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45627 PyObject *resultobj = 0;
45628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45629 int 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_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45639 }
45640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45641 {
45642 PyThreadState* __tstate = wxPyBeginAllowThreads();
45643 result = (int)(arg1)->GetBorder();
45644 wxPyEndAllowThreads(__tstate);
45645 if (PyErr_Occurred()) SWIG_fail;
45646 }
45647 resultobj = SWIG_From_int(static_cast< int >(result));
45648 return resultobj;
45649 fail:
45650 return NULL;
45651 }
45652
45653
45654 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45655 PyObject *resultobj = 0;
45656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45657 wxWindow *result = 0 ;
45658 void *argp1 = 0 ;
45659 int res1 = 0 ;
45660 PyObject *swig_obj[1] ;
45661
45662 if (!args) SWIG_fail;
45663 swig_obj[0] = args;
45664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45665 if (!SWIG_IsOK(res1)) {
45666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45667 }
45668 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45669 {
45670 PyThreadState* __tstate = wxPyBeginAllowThreads();
45671 result = (wxWindow *)(arg1)->GetWindow();
45672 wxPyEndAllowThreads(__tstate);
45673 if (PyErr_Occurred()) SWIG_fail;
45674 }
45675 {
45676 resultobj = wxPyMake_wxObject(result, 0);
45677 }
45678 return resultobj;
45679 fail:
45680 return NULL;
45681 }
45682
45683
45684 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45685 PyObject *resultobj = 0;
45686 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45687 wxWindow *arg2 = (wxWindow *) 0 ;
45688 void *argp1 = 0 ;
45689 int res1 = 0 ;
45690 void *argp2 = 0 ;
45691 int res2 = 0 ;
45692 PyObject * obj0 = 0 ;
45693 PyObject * obj1 = 0 ;
45694 char * kwnames[] = {
45695 (char *) "self",(char *) "window", NULL
45696 };
45697
45698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45700 if (!SWIG_IsOK(res1)) {
45701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45702 }
45703 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45705 if (!SWIG_IsOK(res2)) {
45706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45707 }
45708 arg2 = reinterpret_cast< wxWindow * >(argp2);
45709 {
45710 PyThreadState* __tstate = wxPyBeginAllowThreads();
45711 (arg1)->SetWindow(arg2);
45712 wxPyEndAllowThreads(__tstate);
45713 if (PyErr_Occurred()) SWIG_fail;
45714 }
45715 resultobj = SWIG_Py_Void();
45716 return resultobj;
45717 fail:
45718 return NULL;
45719 }
45720
45721
45722 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45723 PyObject *resultobj = 0;
45724 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45725 wxSizer *result = 0 ;
45726 void *argp1 = 0 ;
45727 int res1 = 0 ;
45728 PyObject *swig_obj[1] ;
45729
45730 if (!args) SWIG_fail;
45731 swig_obj[0] = args;
45732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45733 if (!SWIG_IsOK(res1)) {
45734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45735 }
45736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 result = (wxSizer *)(arg1)->GetSizer();
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 {
45744 resultobj = wxPyMake_wxObject(result, (bool)0);
45745 }
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45755 wxSizer *arg2 = (wxSizer *) 0 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 int res2 = 0 ;
45759 PyObject * obj0 = 0 ;
45760 PyObject * obj1 = 0 ;
45761 char * kwnames[] = {
45762 (char *) "self",(char *) "sizer", NULL
45763 };
45764
45765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45767 if (!SWIG_IsOK(res1)) {
45768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45769 }
45770 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45771 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45772 if (!SWIG_IsOK(res2)) {
45773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45774 }
45775 {
45776 PyThreadState* __tstate = wxPyBeginAllowThreads();
45777 (arg1)->SetSizer(arg2);
45778 wxPyEndAllowThreads(__tstate);
45779 if (PyErr_Occurred()) SWIG_fail;
45780 }
45781 resultobj = SWIG_Py_Void();
45782 return resultobj;
45783 fail:
45784 return NULL;
45785 }
45786
45787
45788 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45789 PyObject *resultobj = 0;
45790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45791 wxSize *result = 0 ;
45792 void *argp1 = 0 ;
45793 int res1 = 0 ;
45794 PyObject *swig_obj[1] ;
45795
45796 if (!args) SWIG_fail;
45797 swig_obj[0] = args;
45798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45799 if (!SWIG_IsOK(res1)) {
45800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45801 }
45802 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 {
45806 wxSize const &_result_ref = (arg1)->GetSpacer();
45807 result = (wxSize *) &_result_ref;
45808 }
45809 wxPyEndAllowThreads(__tstate);
45810 if (PyErr_Occurred()) SWIG_fail;
45811 }
45812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45813 return resultobj;
45814 fail:
45815 return NULL;
45816 }
45817
45818
45819 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45820 PyObject *resultobj = 0;
45821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45822 wxSize *arg2 = 0 ;
45823 void *argp1 = 0 ;
45824 int res1 = 0 ;
45825 wxSize temp2 ;
45826 PyObject * obj0 = 0 ;
45827 PyObject * obj1 = 0 ;
45828 char * kwnames[] = {
45829 (char *) "self",(char *) "size", NULL
45830 };
45831
45832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45834 if (!SWIG_IsOK(res1)) {
45835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45836 }
45837 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45838 {
45839 arg2 = &temp2;
45840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45841 }
45842 {
45843 PyThreadState* __tstate = wxPyBeginAllowThreads();
45844 (arg1)->SetSpacer((wxSize const &)*arg2);
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 resultobj = SWIG_Py_Void();
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45858 bool arg2 ;
45859 void *argp1 = 0 ;
45860 int res1 = 0 ;
45861 bool val2 ;
45862 int ecode2 = 0 ;
45863 PyObject * obj0 = 0 ;
45864 PyObject * obj1 = 0 ;
45865 char * kwnames[] = {
45866 (char *) "self",(char *) "show", NULL
45867 };
45868
45869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45873 }
45874 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45875 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45876 if (!SWIG_IsOK(ecode2)) {
45877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45878 }
45879 arg2 = static_cast< bool >(val2);
45880 {
45881 PyThreadState* __tstate = wxPyBeginAllowThreads();
45882 (arg1)->Show(arg2);
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 resultobj = SWIG_Py_Void();
45887 return resultobj;
45888 fail:
45889 return NULL;
45890 }
45891
45892
45893 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45894 PyObject *resultobj = 0;
45895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45896 bool result;
45897 void *argp1 = 0 ;
45898 int res1 = 0 ;
45899 PyObject *swig_obj[1] ;
45900
45901 if (!args) SWIG_fail;
45902 swig_obj[0] = args;
45903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45904 if (!SWIG_IsOK(res1)) {
45905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45906 }
45907 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 result = (bool)(arg1)->IsShown();
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 {
45915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45916 }
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45924 PyObject *resultobj = 0;
45925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45926 wxPoint result;
45927 void *argp1 = 0 ;
45928 int res1 = 0 ;
45929 PyObject *swig_obj[1] ;
45930
45931 if (!args) SWIG_fail;
45932 swig_obj[0] = args;
45933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45934 if (!SWIG_IsOK(res1)) {
45935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45936 }
45937 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 result = (arg1)->GetPosition();
45941 wxPyEndAllowThreads(__tstate);
45942 if (PyErr_Occurred()) SWIG_fail;
45943 }
45944 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45952 PyObject *resultobj = 0;
45953 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45954 PyObject *result = 0 ;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 PyObject *swig_obj[1] ;
45958
45959 if (!args) SWIG_fail;
45960 swig_obj[0] = args;
45961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45962 if (!SWIG_IsOK(res1)) {
45963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45964 }
45965 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45966 {
45967 PyThreadState* __tstate = wxPyBeginAllowThreads();
45968 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45969 wxPyEndAllowThreads(__tstate);
45970 if (PyErr_Occurred()) SWIG_fail;
45971 }
45972 resultobj = result;
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45980 PyObject *resultobj = 0;
45981 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45982 PyObject *arg2 = (PyObject *) 0 ;
45983 void *argp1 = 0 ;
45984 int res1 = 0 ;
45985 PyObject * obj0 = 0 ;
45986 PyObject * obj1 = 0 ;
45987 char * kwnames[] = {
45988 (char *) "self",(char *) "userData", NULL
45989 };
45990
45991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45995 }
45996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45997 arg2 = obj1;
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 wxSizerItem_SetUserData(arg1,arg2);
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_Py_Void();
46005 return resultobj;
46006 fail:
46007 return NULL;
46008 }
46009
46010
46011 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 PyObject *obj;
46013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46014 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46015 return SWIG_Py_Void();
46016 }
46017
46018 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46019 return SWIG_Python_InitShadowInstance(args);
46020 }
46021
46022 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46023 PyObject *resultobj = 0;
46024 wxSizer *arg1 = (wxSizer *) 0 ;
46025 void *argp1 = 0 ;
46026 int res1 = 0 ;
46027 PyObject *swig_obj[1] ;
46028
46029 if (!args) SWIG_fail;
46030 swig_obj[0] = args;
46031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46032 if (!SWIG_IsOK(res1)) {
46033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46034 }
46035 arg1 = reinterpret_cast< wxSizer * >(argp1);
46036 {
46037 PyThreadState* __tstate = wxPyBeginAllowThreads();
46038 delete arg1;
46039
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 resultobj = SWIG_Py_Void();
46044 return resultobj;
46045 fail:
46046 return NULL;
46047 }
46048
46049
46050 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46051 PyObject *resultobj = 0;
46052 wxSizer *arg1 = (wxSizer *) 0 ;
46053 PyObject *arg2 = (PyObject *) 0 ;
46054 void *argp1 = 0 ;
46055 int res1 = 0 ;
46056 PyObject * obj0 = 0 ;
46057 PyObject * obj1 = 0 ;
46058 char * kwnames[] = {
46059 (char *) "self",(char *) "_self", NULL
46060 };
46061
46062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46064 if (!SWIG_IsOK(res1)) {
46065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46066 }
46067 arg1 = reinterpret_cast< wxSizer * >(argp1);
46068 arg2 = obj1;
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 wxSizer__setOORInfo(arg1,arg2);
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 resultobj = SWIG_Py_Void();
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = 0;
46084 wxSizer *arg1 = (wxSizer *) 0 ;
46085 PyObject *arg2 = (PyObject *) 0 ;
46086 int arg3 = (int) 0 ;
46087 int arg4 = (int) 0 ;
46088 int arg5 = (int) 0 ;
46089 PyObject *arg6 = (PyObject *) NULL ;
46090 wxSizerItem *result = 0 ;
46091 void *argp1 = 0 ;
46092 int res1 = 0 ;
46093 int val3 ;
46094 int ecode3 = 0 ;
46095 int val4 ;
46096 int ecode4 = 0 ;
46097 int val5 ;
46098 int ecode5 = 0 ;
46099 PyObject * obj0 = 0 ;
46100 PyObject * obj1 = 0 ;
46101 PyObject * obj2 = 0 ;
46102 PyObject * obj3 = 0 ;
46103 PyObject * obj4 = 0 ;
46104 PyObject * obj5 = 0 ;
46105 char * kwnames[] = {
46106 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46107 };
46108
46109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46111 if (!SWIG_IsOK(res1)) {
46112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46113 }
46114 arg1 = reinterpret_cast< wxSizer * >(argp1);
46115 arg2 = obj1;
46116 if (obj2) {
46117 ecode3 = SWIG_AsVal_int(obj2, &val3);
46118 if (!SWIG_IsOK(ecode3)) {
46119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46120 }
46121 arg3 = static_cast< int >(val3);
46122 }
46123 if (obj3) {
46124 ecode4 = SWIG_AsVal_int(obj3, &val4);
46125 if (!SWIG_IsOK(ecode4)) {
46126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46127 }
46128 arg4 = static_cast< int >(val4);
46129 }
46130 if (obj4) {
46131 ecode5 = SWIG_AsVal_int(obj4, &val5);
46132 if (!SWIG_IsOK(ecode5)) {
46133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46134 }
46135 arg5 = static_cast< int >(val5);
46136 }
46137 if (obj5) {
46138 arg6 = obj5;
46139 }
46140 {
46141 PyThreadState* __tstate = wxPyBeginAllowThreads();
46142 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46143 wxPyEndAllowThreads(__tstate);
46144 if (PyErr_Occurred()) SWIG_fail;
46145 }
46146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46147 return resultobj;
46148 fail:
46149 return NULL;
46150 }
46151
46152
46153 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46154 PyObject *resultobj = 0;
46155 wxSizer *arg1 = (wxSizer *) 0 ;
46156 int arg2 ;
46157 PyObject *arg3 = (PyObject *) 0 ;
46158 int arg4 = (int) 0 ;
46159 int arg5 = (int) 0 ;
46160 int arg6 = (int) 0 ;
46161 PyObject *arg7 = (PyObject *) NULL ;
46162 wxSizerItem *result = 0 ;
46163 void *argp1 = 0 ;
46164 int res1 = 0 ;
46165 int val2 ;
46166 int ecode2 = 0 ;
46167 int val4 ;
46168 int ecode4 = 0 ;
46169 int val5 ;
46170 int ecode5 = 0 ;
46171 int val6 ;
46172 int ecode6 = 0 ;
46173 PyObject * obj0 = 0 ;
46174 PyObject * obj1 = 0 ;
46175 PyObject * obj2 = 0 ;
46176 PyObject * obj3 = 0 ;
46177 PyObject * obj4 = 0 ;
46178 PyObject * obj5 = 0 ;
46179 PyObject * obj6 = 0 ;
46180 char * kwnames[] = {
46181 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46182 };
46183
46184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46186 if (!SWIG_IsOK(res1)) {
46187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46188 }
46189 arg1 = reinterpret_cast< wxSizer * >(argp1);
46190 ecode2 = SWIG_AsVal_int(obj1, &val2);
46191 if (!SWIG_IsOK(ecode2)) {
46192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46193 }
46194 arg2 = static_cast< int >(val2);
46195 arg3 = obj2;
46196 if (obj3) {
46197 ecode4 = SWIG_AsVal_int(obj3, &val4);
46198 if (!SWIG_IsOK(ecode4)) {
46199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46200 }
46201 arg4 = static_cast< int >(val4);
46202 }
46203 if (obj4) {
46204 ecode5 = SWIG_AsVal_int(obj4, &val5);
46205 if (!SWIG_IsOK(ecode5)) {
46206 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46207 }
46208 arg5 = static_cast< int >(val5);
46209 }
46210 if (obj5) {
46211 ecode6 = SWIG_AsVal_int(obj5, &val6);
46212 if (!SWIG_IsOK(ecode6)) {
46213 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46214 }
46215 arg6 = static_cast< int >(val6);
46216 }
46217 if (obj6) {
46218 arg7 = obj6;
46219 }
46220 {
46221 PyThreadState* __tstate = wxPyBeginAllowThreads();
46222 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46223 wxPyEndAllowThreads(__tstate);
46224 if (PyErr_Occurred()) SWIG_fail;
46225 }
46226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46234 PyObject *resultobj = 0;
46235 wxSizer *arg1 = (wxSizer *) 0 ;
46236 PyObject *arg2 = (PyObject *) 0 ;
46237 int arg3 = (int) 0 ;
46238 int arg4 = (int) 0 ;
46239 int arg5 = (int) 0 ;
46240 PyObject *arg6 = (PyObject *) NULL ;
46241 wxSizerItem *result = 0 ;
46242 void *argp1 = 0 ;
46243 int res1 = 0 ;
46244 int val3 ;
46245 int ecode3 = 0 ;
46246 int val4 ;
46247 int ecode4 = 0 ;
46248 int val5 ;
46249 int ecode5 = 0 ;
46250 PyObject * obj0 = 0 ;
46251 PyObject * obj1 = 0 ;
46252 PyObject * obj2 = 0 ;
46253 PyObject * obj3 = 0 ;
46254 PyObject * obj4 = 0 ;
46255 PyObject * obj5 = 0 ;
46256 char * kwnames[] = {
46257 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46258 };
46259
46260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46262 if (!SWIG_IsOK(res1)) {
46263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46264 }
46265 arg1 = reinterpret_cast< wxSizer * >(argp1);
46266 arg2 = obj1;
46267 if (obj2) {
46268 ecode3 = SWIG_AsVal_int(obj2, &val3);
46269 if (!SWIG_IsOK(ecode3)) {
46270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46271 }
46272 arg3 = static_cast< int >(val3);
46273 }
46274 if (obj3) {
46275 ecode4 = SWIG_AsVal_int(obj3, &val4);
46276 if (!SWIG_IsOK(ecode4)) {
46277 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46278 }
46279 arg4 = static_cast< int >(val4);
46280 }
46281 if (obj4) {
46282 ecode5 = SWIG_AsVal_int(obj4, &val5);
46283 if (!SWIG_IsOK(ecode5)) {
46284 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46285 }
46286 arg5 = static_cast< int >(val5);
46287 }
46288 if (obj5) {
46289 arg6 = obj5;
46290 }
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46298 return resultobj;
46299 fail:
46300 return NULL;
46301 }
46302
46303
46304 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46305 PyObject *resultobj = 0;
46306 wxSizer *arg1 = (wxSizer *) 0 ;
46307 PyObject *arg2 = (PyObject *) 0 ;
46308 bool result;
46309 void *argp1 = 0 ;
46310 int res1 = 0 ;
46311 PyObject * obj0 = 0 ;
46312 PyObject * obj1 = 0 ;
46313 char * kwnames[] = {
46314 (char *) "self",(char *) "item", NULL
46315 };
46316
46317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46319 if (!SWIG_IsOK(res1)) {
46320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46321 }
46322 arg1 = reinterpret_cast< wxSizer * >(argp1);
46323 arg2 = obj1;
46324 {
46325 PyThreadState* __tstate = wxPyBeginAllowThreads();
46326 result = (bool)wxSizer_Remove(arg1,arg2);
46327 wxPyEndAllowThreads(__tstate);
46328 if (PyErr_Occurred()) SWIG_fail;
46329 }
46330 {
46331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46332 }
46333 return resultobj;
46334 fail:
46335 return NULL;
46336 }
46337
46338
46339 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46340 PyObject *resultobj = 0;
46341 wxSizer *arg1 = (wxSizer *) 0 ;
46342 PyObject *arg2 = (PyObject *) 0 ;
46343 bool result;
46344 void *argp1 = 0 ;
46345 int res1 = 0 ;
46346 PyObject * obj0 = 0 ;
46347 PyObject * obj1 = 0 ;
46348 char * kwnames[] = {
46349 (char *) "self",(char *) "item", NULL
46350 };
46351
46352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46354 if (!SWIG_IsOK(res1)) {
46355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46356 }
46357 arg1 = reinterpret_cast< wxSizer * >(argp1);
46358 arg2 = obj1;
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 result = (bool)wxSizer_Detach(arg1,arg2);
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 {
46366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46367 }
46368 return resultobj;
46369 fail:
46370 return NULL;
46371 }
46372
46373
46374 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46375 PyObject *resultobj = 0;
46376 wxSizer *arg1 = (wxSizer *) 0 ;
46377 PyObject *arg2 = (PyObject *) 0 ;
46378 wxSizerItem *result = 0 ;
46379 void *argp1 = 0 ;
46380 int res1 = 0 ;
46381 PyObject * obj0 = 0 ;
46382 PyObject * obj1 = 0 ;
46383 char * kwnames[] = {
46384 (char *) "self",(char *) "item", NULL
46385 };
46386
46387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46389 if (!SWIG_IsOK(res1)) {
46390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46391 }
46392 arg1 = reinterpret_cast< wxSizer * >(argp1);
46393 arg2 = obj1;
46394 {
46395 PyThreadState* __tstate = wxPyBeginAllowThreads();
46396 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46397 wxPyEndAllowThreads(__tstate);
46398 if (PyErr_Occurred()) SWIG_fail;
46399 }
46400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46401 return resultobj;
46402 fail:
46403 return NULL;
46404 }
46405
46406
46407 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46408 PyObject *resultobj = 0;
46409 wxSizer *arg1 = (wxSizer *) 0 ;
46410 PyObject *arg2 = (PyObject *) 0 ;
46411 wxSize *arg3 = 0 ;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 wxSize temp3 ;
46415 PyObject * obj0 = 0 ;
46416 PyObject * obj1 = 0 ;
46417 PyObject * obj2 = 0 ;
46418 char * kwnames[] = {
46419 (char *) "self",(char *) "item",(char *) "size", NULL
46420 };
46421
46422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46424 if (!SWIG_IsOK(res1)) {
46425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46426 }
46427 arg1 = reinterpret_cast< wxSizer * >(argp1);
46428 arg2 = obj1;
46429 {
46430 arg3 = &temp3;
46431 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46432 }
46433 {
46434 PyThreadState* __tstate = wxPyBeginAllowThreads();
46435 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46436 wxPyEndAllowThreads(__tstate);
46437 if (PyErr_Occurred()) SWIG_fail;
46438 }
46439 resultobj = SWIG_Py_Void();
46440 return resultobj;
46441 fail:
46442 return NULL;
46443 }
46444
46445
46446 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46447 PyObject *resultobj = 0;
46448 wxSizer *arg1 = (wxSizer *) 0 ;
46449 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46450 wxSizerItem *result = 0 ;
46451 void *argp1 = 0 ;
46452 int res1 = 0 ;
46453 int res2 = 0 ;
46454 PyObject * obj0 = 0 ;
46455 PyObject * obj1 = 0 ;
46456 char * kwnames[] = {
46457 (char *) "self",(char *) "item", NULL
46458 };
46459
46460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46462 if (!SWIG_IsOK(res1)) {
46463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46464 }
46465 arg1 = reinterpret_cast< wxSizer * >(argp1);
46466 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46467 if (!SWIG_IsOK(res2)) {
46468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46469 }
46470 {
46471 PyThreadState* __tstate = wxPyBeginAllowThreads();
46472 result = (wxSizerItem *)(arg1)->Add(arg2);
46473 wxPyEndAllowThreads(__tstate);
46474 if (PyErr_Occurred()) SWIG_fail;
46475 }
46476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46477 return resultobj;
46478 fail:
46479 return NULL;
46480 }
46481
46482
46483 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46484 PyObject *resultobj = 0;
46485 wxSizer *arg1 = (wxSizer *) 0 ;
46486 size_t arg2 ;
46487 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46488 wxSizerItem *result = 0 ;
46489 void *argp1 = 0 ;
46490 int res1 = 0 ;
46491 size_t val2 ;
46492 int ecode2 = 0 ;
46493 int res3 = 0 ;
46494 PyObject * obj0 = 0 ;
46495 PyObject * obj1 = 0 ;
46496 PyObject * obj2 = 0 ;
46497 char * kwnames[] = {
46498 (char *) "self",(char *) "index",(char *) "item", NULL
46499 };
46500
46501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46503 if (!SWIG_IsOK(res1)) {
46504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46505 }
46506 arg1 = reinterpret_cast< wxSizer * >(argp1);
46507 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46508 if (!SWIG_IsOK(ecode2)) {
46509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46510 }
46511 arg2 = static_cast< size_t >(val2);
46512 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46513 if (!SWIG_IsOK(res3)) {
46514 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46515 }
46516 {
46517 PyThreadState* __tstate = wxPyBeginAllowThreads();
46518 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46519 wxPyEndAllowThreads(__tstate);
46520 if (PyErr_Occurred()) SWIG_fail;
46521 }
46522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46523 return resultobj;
46524 fail:
46525 return NULL;
46526 }
46527
46528
46529 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46530 PyObject *resultobj = 0;
46531 wxSizer *arg1 = (wxSizer *) 0 ;
46532 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46533 wxSizerItem *result = 0 ;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 int res2 = 0 ;
46537 PyObject * obj0 = 0 ;
46538 PyObject * obj1 = 0 ;
46539 char * kwnames[] = {
46540 (char *) "self",(char *) "item", NULL
46541 };
46542
46543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46545 if (!SWIG_IsOK(res1)) {
46546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46547 }
46548 arg1 = reinterpret_cast< wxSizer * >(argp1);
46549 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46550 if (!SWIG_IsOK(res2)) {
46551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46552 }
46553 {
46554 PyThreadState* __tstate = wxPyBeginAllowThreads();
46555 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46556 wxPyEndAllowThreads(__tstate);
46557 if (PyErr_Occurred()) SWIG_fail;
46558 }
46559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46560 return resultobj;
46561 fail:
46562 return NULL;
46563 }
46564
46565
46566 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46567 PyObject *resultobj = 0;
46568 wxSizer *arg1 = (wxSizer *) 0 ;
46569 int arg2 ;
46570 int arg3 ;
46571 int arg4 ;
46572 int arg5 ;
46573 void *argp1 = 0 ;
46574 int res1 = 0 ;
46575 int val2 ;
46576 int ecode2 = 0 ;
46577 int val3 ;
46578 int ecode3 = 0 ;
46579 int val4 ;
46580 int ecode4 = 0 ;
46581 int val5 ;
46582 int ecode5 = 0 ;
46583 PyObject * obj0 = 0 ;
46584 PyObject * obj1 = 0 ;
46585 PyObject * obj2 = 0 ;
46586 PyObject * obj3 = 0 ;
46587 PyObject * obj4 = 0 ;
46588 char * kwnames[] = {
46589 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46590 };
46591
46592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizer * >(argp1);
46598 ecode2 = SWIG_AsVal_int(obj1, &val2);
46599 if (!SWIG_IsOK(ecode2)) {
46600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46601 }
46602 arg2 = static_cast< int >(val2);
46603 ecode3 = SWIG_AsVal_int(obj2, &val3);
46604 if (!SWIG_IsOK(ecode3)) {
46605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46606 }
46607 arg3 = static_cast< int >(val3);
46608 ecode4 = SWIG_AsVal_int(obj3, &val4);
46609 if (!SWIG_IsOK(ecode4)) {
46610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46611 }
46612 arg4 = static_cast< int >(val4);
46613 ecode5 = SWIG_AsVal_int(obj4, &val5);
46614 if (!SWIG_IsOK(ecode5)) {
46615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46616 }
46617 arg5 = static_cast< int >(val5);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 resultobj = SWIG_Py_Void();
46625 return resultobj;
46626 fail:
46627 return NULL;
46628 }
46629
46630
46631 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46632 PyObject *resultobj = 0;
46633 wxSizer *arg1 = (wxSizer *) 0 ;
46634 wxSize *arg2 = 0 ;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 wxSize temp2 ;
46638 PyObject * obj0 = 0 ;
46639 PyObject * obj1 = 0 ;
46640 char * kwnames[] = {
46641 (char *) "self",(char *) "size", NULL
46642 };
46643
46644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46646 if (!SWIG_IsOK(res1)) {
46647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46648 }
46649 arg1 = reinterpret_cast< wxSizer * >(argp1);
46650 {
46651 arg2 = &temp2;
46652 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46653 }
46654 {
46655 PyThreadState* __tstate = wxPyBeginAllowThreads();
46656 (arg1)->SetMinSize((wxSize const &)*arg2);
46657 wxPyEndAllowThreads(__tstate);
46658 if (PyErr_Occurred()) SWIG_fail;
46659 }
46660 resultobj = SWIG_Py_Void();
46661 return resultobj;
46662 fail:
46663 return NULL;
46664 }
46665
46666
46667 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46668 PyObject *resultobj = 0;
46669 wxSizer *arg1 = (wxSizer *) 0 ;
46670 wxSize result;
46671 void *argp1 = 0 ;
46672 int res1 = 0 ;
46673 PyObject *swig_obj[1] ;
46674
46675 if (!args) SWIG_fail;
46676 swig_obj[0] = args;
46677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46678 if (!SWIG_IsOK(res1)) {
46679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46680 }
46681 arg1 = reinterpret_cast< wxSizer * >(argp1);
46682 {
46683 PyThreadState* __tstate = wxPyBeginAllowThreads();
46684 result = (arg1)->GetSize();
46685 wxPyEndAllowThreads(__tstate);
46686 if (PyErr_Occurred()) SWIG_fail;
46687 }
46688 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46689 return resultobj;
46690 fail:
46691 return NULL;
46692 }
46693
46694
46695 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46696 PyObject *resultobj = 0;
46697 wxSizer *arg1 = (wxSizer *) 0 ;
46698 wxPoint result;
46699 void *argp1 = 0 ;
46700 int res1 = 0 ;
46701 PyObject *swig_obj[1] ;
46702
46703 if (!args) SWIG_fail;
46704 swig_obj[0] = args;
46705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46706 if (!SWIG_IsOK(res1)) {
46707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46708 }
46709 arg1 = reinterpret_cast< wxSizer * >(argp1);
46710 {
46711 PyThreadState* __tstate = wxPyBeginAllowThreads();
46712 result = (arg1)->GetPosition();
46713 wxPyEndAllowThreads(__tstate);
46714 if (PyErr_Occurred()) SWIG_fail;
46715 }
46716 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46717 return resultobj;
46718 fail:
46719 return NULL;
46720 }
46721
46722
46723 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46724 PyObject *resultobj = 0;
46725 wxSizer *arg1 = (wxSizer *) 0 ;
46726 wxSize result;
46727 void *argp1 = 0 ;
46728 int res1 = 0 ;
46729 PyObject *swig_obj[1] ;
46730
46731 if (!args) SWIG_fail;
46732 swig_obj[0] = args;
46733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46734 if (!SWIG_IsOK(res1)) {
46735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46736 }
46737 arg1 = reinterpret_cast< wxSizer * >(argp1);
46738 {
46739 PyThreadState* __tstate = wxPyBeginAllowThreads();
46740 result = (arg1)->GetMinSize();
46741 wxPyEndAllowThreads(__tstate);
46742 if (PyErr_Occurred()) SWIG_fail;
46743 }
46744 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46745 return resultobj;
46746 fail:
46747 return NULL;
46748 }
46749
46750
46751 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46752 PyObject *resultobj = 0;
46753 wxSizer *arg1 = (wxSizer *) 0 ;
46754 void *argp1 = 0 ;
46755 int res1 = 0 ;
46756 PyObject *swig_obj[1] ;
46757
46758 if (!args) SWIG_fail;
46759 swig_obj[0] = args;
46760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46761 if (!SWIG_IsOK(res1)) {
46762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46763 }
46764 arg1 = reinterpret_cast< wxSizer * >(argp1);
46765 {
46766 PyThreadState* __tstate = wxPyBeginAllowThreads();
46767 (arg1)->RecalcSizes();
46768 wxPyEndAllowThreads(__tstate);
46769 if (PyErr_Occurred()) SWIG_fail;
46770 }
46771 resultobj = SWIG_Py_Void();
46772 return resultobj;
46773 fail:
46774 return NULL;
46775 }
46776
46777
46778 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46779 PyObject *resultobj = 0;
46780 wxSizer *arg1 = (wxSizer *) 0 ;
46781 wxSize result;
46782 void *argp1 = 0 ;
46783 int res1 = 0 ;
46784 PyObject *swig_obj[1] ;
46785
46786 if (!args) SWIG_fail;
46787 swig_obj[0] = args;
46788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46789 if (!SWIG_IsOK(res1)) {
46790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46791 }
46792 arg1 = reinterpret_cast< wxSizer * >(argp1);
46793 {
46794 PyThreadState* __tstate = wxPyBeginAllowThreads();
46795 result = (arg1)->CalcMin();
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46807 PyObject *resultobj = 0;
46808 wxSizer *arg1 = (wxSizer *) 0 ;
46809 void *argp1 = 0 ;
46810 int res1 = 0 ;
46811 PyObject *swig_obj[1] ;
46812
46813 if (!args) SWIG_fail;
46814 swig_obj[0] = args;
46815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46816 if (!SWIG_IsOK(res1)) {
46817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46818 }
46819 arg1 = reinterpret_cast< wxSizer * >(argp1);
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 (arg1)->Layout();
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_Py_Void();
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46834 PyObject *resultobj = 0;
46835 wxSizer *arg1 = (wxSizer *) 0 ;
46836 wxWindow *arg2 = (wxWindow *) 0 ;
46837 wxSize result;
46838 void *argp1 = 0 ;
46839 int res1 = 0 ;
46840 void *argp2 = 0 ;
46841 int res2 = 0 ;
46842 PyObject * obj0 = 0 ;
46843 PyObject * obj1 = 0 ;
46844 char * kwnames[] = {
46845 (char *) "self",(char *) "window", NULL
46846 };
46847
46848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46850 if (!SWIG_IsOK(res1)) {
46851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46852 }
46853 arg1 = reinterpret_cast< wxSizer * >(argp1);
46854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46855 if (!SWIG_IsOK(res2)) {
46856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46857 }
46858 arg2 = reinterpret_cast< wxWindow * >(argp2);
46859 {
46860 PyThreadState* __tstate = wxPyBeginAllowThreads();
46861 result = (arg1)->Fit(arg2);
46862 wxPyEndAllowThreads(__tstate);
46863 if (PyErr_Occurred()) SWIG_fail;
46864 }
46865 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46866 return resultobj;
46867 fail:
46868 return NULL;
46869 }
46870
46871
46872 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46873 PyObject *resultobj = 0;
46874 wxSizer *arg1 = (wxSizer *) 0 ;
46875 wxWindow *arg2 = (wxWindow *) 0 ;
46876 void *argp1 = 0 ;
46877 int res1 = 0 ;
46878 void *argp2 = 0 ;
46879 int res2 = 0 ;
46880 PyObject * obj0 = 0 ;
46881 PyObject * obj1 = 0 ;
46882 char * kwnames[] = {
46883 (char *) "self",(char *) "window", NULL
46884 };
46885
46886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46888 if (!SWIG_IsOK(res1)) {
46889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46890 }
46891 arg1 = reinterpret_cast< wxSizer * >(argp1);
46892 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46893 if (!SWIG_IsOK(res2)) {
46894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46895 }
46896 arg2 = reinterpret_cast< wxWindow * >(argp2);
46897 {
46898 PyThreadState* __tstate = wxPyBeginAllowThreads();
46899 (arg1)->FitInside(arg2);
46900 wxPyEndAllowThreads(__tstate);
46901 if (PyErr_Occurred()) SWIG_fail;
46902 }
46903 resultobj = SWIG_Py_Void();
46904 return resultobj;
46905 fail:
46906 return NULL;
46907 }
46908
46909
46910 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46911 PyObject *resultobj = 0;
46912 wxSizer *arg1 = (wxSizer *) 0 ;
46913 wxWindow *arg2 = (wxWindow *) 0 ;
46914 void *argp1 = 0 ;
46915 int res1 = 0 ;
46916 void *argp2 = 0 ;
46917 int res2 = 0 ;
46918 PyObject * obj0 = 0 ;
46919 PyObject * obj1 = 0 ;
46920 char * kwnames[] = {
46921 (char *) "self",(char *) "window", NULL
46922 };
46923
46924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46926 if (!SWIG_IsOK(res1)) {
46927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46928 }
46929 arg1 = reinterpret_cast< wxSizer * >(argp1);
46930 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46931 if (!SWIG_IsOK(res2)) {
46932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46933 }
46934 arg2 = reinterpret_cast< wxWindow * >(argp2);
46935 {
46936 PyThreadState* __tstate = wxPyBeginAllowThreads();
46937 (arg1)->SetSizeHints(arg2);
46938 wxPyEndAllowThreads(__tstate);
46939 if (PyErr_Occurred()) SWIG_fail;
46940 }
46941 resultobj = SWIG_Py_Void();
46942 return resultobj;
46943 fail:
46944 return NULL;
46945 }
46946
46947
46948 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46949 PyObject *resultobj = 0;
46950 wxSizer *arg1 = (wxSizer *) 0 ;
46951 wxWindow *arg2 = (wxWindow *) 0 ;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 void *argp2 = 0 ;
46955 int res2 = 0 ;
46956 PyObject * obj0 = 0 ;
46957 PyObject * obj1 = 0 ;
46958 char * kwnames[] = {
46959 (char *) "self",(char *) "window", NULL
46960 };
46961
46962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46964 if (!SWIG_IsOK(res1)) {
46965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46966 }
46967 arg1 = reinterpret_cast< wxSizer * >(argp1);
46968 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46969 if (!SWIG_IsOK(res2)) {
46970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46971 }
46972 arg2 = reinterpret_cast< wxWindow * >(argp2);
46973 {
46974 PyThreadState* __tstate = wxPyBeginAllowThreads();
46975 (arg1)->SetVirtualSizeHints(arg2);
46976 wxPyEndAllowThreads(__tstate);
46977 if (PyErr_Occurred()) SWIG_fail;
46978 }
46979 resultobj = SWIG_Py_Void();
46980 return resultobj;
46981 fail:
46982 return NULL;
46983 }
46984
46985
46986 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46987 PyObject *resultobj = 0;
46988 wxSizer *arg1 = (wxSizer *) 0 ;
46989 bool arg2 = (bool) false ;
46990 void *argp1 = 0 ;
46991 int res1 = 0 ;
46992 bool val2 ;
46993 int ecode2 = 0 ;
46994 PyObject * obj0 = 0 ;
46995 PyObject * obj1 = 0 ;
46996 char * kwnames[] = {
46997 (char *) "self",(char *) "deleteWindows", NULL
46998 };
46999
47000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47002 if (!SWIG_IsOK(res1)) {
47003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47004 }
47005 arg1 = reinterpret_cast< wxSizer * >(argp1);
47006 if (obj1) {
47007 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47008 if (!SWIG_IsOK(ecode2)) {
47009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47010 }
47011 arg2 = static_cast< bool >(val2);
47012 }
47013 {
47014 PyThreadState* __tstate = wxPyBeginAllowThreads();
47015 (arg1)->Clear(arg2);
47016 wxPyEndAllowThreads(__tstate);
47017 if (PyErr_Occurred()) SWIG_fail;
47018 }
47019 resultobj = SWIG_Py_Void();
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47027 PyObject *resultobj = 0;
47028 wxSizer *arg1 = (wxSizer *) 0 ;
47029 void *argp1 = 0 ;
47030 int res1 = 0 ;
47031 PyObject *swig_obj[1] ;
47032
47033 if (!args) SWIG_fail;
47034 swig_obj[0] = args;
47035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47036 if (!SWIG_IsOK(res1)) {
47037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47038 }
47039 arg1 = reinterpret_cast< wxSizer * >(argp1);
47040 {
47041 PyThreadState* __tstate = wxPyBeginAllowThreads();
47042 (arg1)->DeleteWindows();
47043 wxPyEndAllowThreads(__tstate);
47044 if (PyErr_Occurred()) SWIG_fail;
47045 }
47046 resultobj = SWIG_Py_Void();
47047 return resultobj;
47048 fail:
47049 return NULL;
47050 }
47051
47052
47053 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47054 PyObject *resultobj = 0;
47055 wxSizer *arg1 = (wxSizer *) 0 ;
47056 PyObject *result = 0 ;
47057 void *argp1 = 0 ;
47058 int res1 = 0 ;
47059 PyObject *swig_obj[1] ;
47060
47061 if (!args) SWIG_fail;
47062 swig_obj[0] = args;
47063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47064 if (!SWIG_IsOK(res1)) {
47065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47066 }
47067 arg1 = reinterpret_cast< wxSizer * >(argp1);
47068 {
47069 PyThreadState* __tstate = wxPyBeginAllowThreads();
47070 result = (PyObject *)wxSizer_GetChildren(arg1);
47071 wxPyEndAllowThreads(__tstate);
47072 if (PyErr_Occurred()) SWIG_fail;
47073 }
47074 resultobj = result;
47075 return resultobj;
47076 fail:
47077 return NULL;
47078 }
47079
47080
47081 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47082 PyObject *resultobj = 0;
47083 wxSizer *arg1 = (wxSizer *) 0 ;
47084 PyObject *arg2 = (PyObject *) 0 ;
47085 bool arg3 = (bool) true ;
47086 bool arg4 = (bool) false ;
47087 bool result;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 bool val3 ;
47091 int ecode3 = 0 ;
47092 bool val4 ;
47093 int ecode4 = 0 ;
47094 PyObject * obj0 = 0 ;
47095 PyObject * obj1 = 0 ;
47096 PyObject * obj2 = 0 ;
47097 PyObject * obj3 = 0 ;
47098 char * kwnames[] = {
47099 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47100 };
47101
47102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47104 if (!SWIG_IsOK(res1)) {
47105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47106 }
47107 arg1 = reinterpret_cast< wxSizer * >(argp1);
47108 arg2 = obj1;
47109 if (obj2) {
47110 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47111 if (!SWIG_IsOK(ecode3)) {
47112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47113 }
47114 arg3 = static_cast< bool >(val3);
47115 }
47116 if (obj3) {
47117 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47118 if (!SWIG_IsOK(ecode4)) {
47119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47120 }
47121 arg4 = static_cast< bool >(val4);
47122 }
47123 {
47124 PyThreadState* __tstate = wxPyBeginAllowThreads();
47125 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47126 wxPyEndAllowThreads(__tstate);
47127 if (PyErr_Occurred()) SWIG_fail;
47128 }
47129 {
47130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47131 }
47132 return resultobj;
47133 fail:
47134 return NULL;
47135 }
47136
47137
47138 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47139 PyObject *resultobj = 0;
47140 wxSizer *arg1 = (wxSizer *) 0 ;
47141 PyObject *arg2 = (PyObject *) 0 ;
47142 bool result;
47143 void *argp1 = 0 ;
47144 int res1 = 0 ;
47145 PyObject * obj0 = 0 ;
47146 PyObject * obj1 = 0 ;
47147 char * kwnames[] = {
47148 (char *) "self",(char *) "item", NULL
47149 };
47150
47151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47153 if (!SWIG_IsOK(res1)) {
47154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47155 }
47156 arg1 = reinterpret_cast< wxSizer * >(argp1);
47157 arg2 = obj1;
47158 {
47159 PyThreadState* __tstate = wxPyBeginAllowThreads();
47160 result = (bool)wxSizer_IsShown(arg1,arg2);
47161 wxPyEndAllowThreads(__tstate);
47162 if (PyErr_Occurred()) SWIG_fail;
47163 }
47164 {
47165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47166 }
47167 return resultobj;
47168 fail:
47169 return NULL;
47170 }
47171
47172
47173 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47174 PyObject *resultobj = 0;
47175 wxSizer *arg1 = (wxSizer *) 0 ;
47176 bool arg2 ;
47177 void *argp1 = 0 ;
47178 int res1 = 0 ;
47179 bool val2 ;
47180 int ecode2 = 0 ;
47181 PyObject * obj0 = 0 ;
47182 PyObject * obj1 = 0 ;
47183 char * kwnames[] = {
47184 (char *) "self",(char *) "show", NULL
47185 };
47186
47187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47189 if (!SWIG_IsOK(res1)) {
47190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47191 }
47192 arg1 = reinterpret_cast< wxSizer * >(argp1);
47193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47194 if (!SWIG_IsOK(ecode2)) {
47195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47196 }
47197 arg2 = static_cast< bool >(val2);
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 (arg1)->ShowItems(arg2);
47201 wxPyEndAllowThreads(__tstate);
47202 if (PyErr_Occurred()) SWIG_fail;
47203 }
47204 resultobj = SWIG_Py_Void();
47205 return resultobj;
47206 fail:
47207 return NULL;
47208 }
47209
47210
47211 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47212 PyObject *obj;
47213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47214 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47215 return SWIG_Py_Void();
47216 }
47217
47218 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47219 PyObject *resultobj = 0;
47220 wxPySizer *result = 0 ;
47221
47222 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47223 {
47224 PyThreadState* __tstate = wxPyBeginAllowThreads();
47225 result = (wxPySizer *)new wxPySizer();
47226 wxPyEndAllowThreads(__tstate);
47227 if (PyErr_Occurred()) SWIG_fail;
47228 }
47229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47230 return resultobj;
47231 fail:
47232 return NULL;
47233 }
47234
47235
47236 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47237 PyObject *resultobj = 0;
47238 wxPySizer *arg1 = (wxPySizer *) 0 ;
47239 PyObject *arg2 = (PyObject *) 0 ;
47240 PyObject *arg3 = (PyObject *) 0 ;
47241 void *argp1 = 0 ;
47242 int res1 = 0 ;
47243 PyObject * obj0 = 0 ;
47244 PyObject * obj1 = 0 ;
47245 PyObject * obj2 = 0 ;
47246 char * kwnames[] = {
47247 (char *) "self",(char *) "self",(char *) "_class", NULL
47248 };
47249
47250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47252 if (!SWIG_IsOK(res1)) {
47253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47254 }
47255 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47256 arg2 = obj1;
47257 arg3 = obj2;
47258 {
47259 PyThreadState* __tstate = wxPyBeginAllowThreads();
47260 (arg1)->_setCallbackInfo(arg2,arg3);
47261 wxPyEndAllowThreads(__tstate);
47262 if (PyErr_Occurred()) SWIG_fail;
47263 }
47264 resultobj = SWIG_Py_Void();
47265 return resultobj;
47266 fail:
47267 return NULL;
47268 }
47269
47270
47271 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47272 PyObject *obj;
47273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47274 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47275 return SWIG_Py_Void();
47276 }
47277
47278 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47279 return SWIG_Python_InitShadowInstance(args);
47280 }
47281
47282 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47283 PyObject *resultobj = 0;
47284 int arg1 = (int) wxHORIZONTAL ;
47285 wxBoxSizer *result = 0 ;
47286 int val1 ;
47287 int ecode1 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 char * kwnames[] = {
47290 (char *) "orient", NULL
47291 };
47292
47293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47294 if (obj0) {
47295 ecode1 = SWIG_AsVal_int(obj0, &val1);
47296 if (!SWIG_IsOK(ecode1)) {
47297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47298 }
47299 arg1 = static_cast< int >(val1);
47300 }
47301 {
47302 PyThreadState* __tstate = wxPyBeginAllowThreads();
47303 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47304 wxPyEndAllowThreads(__tstate);
47305 if (PyErr_Occurred()) SWIG_fail;
47306 }
47307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47308 return resultobj;
47309 fail:
47310 return NULL;
47311 }
47312
47313
47314 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47315 PyObject *resultobj = 0;
47316 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47317 int result;
47318 void *argp1 = 0 ;
47319 int res1 = 0 ;
47320 PyObject *swig_obj[1] ;
47321
47322 if (!args) SWIG_fail;
47323 swig_obj[0] = args;
47324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47325 if (!SWIG_IsOK(res1)) {
47326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47327 }
47328 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47329 {
47330 PyThreadState* __tstate = wxPyBeginAllowThreads();
47331 result = (int)(arg1)->GetOrientation();
47332 wxPyEndAllowThreads(__tstate);
47333 if (PyErr_Occurred()) SWIG_fail;
47334 }
47335 resultobj = SWIG_From_int(static_cast< int >(result));
47336 return resultobj;
47337 fail:
47338 return NULL;
47339 }
47340
47341
47342 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47343 PyObject *resultobj = 0;
47344 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47345 int arg2 ;
47346 void *argp1 = 0 ;
47347 int res1 = 0 ;
47348 int val2 ;
47349 int ecode2 = 0 ;
47350 PyObject * obj0 = 0 ;
47351 PyObject * obj1 = 0 ;
47352 char * kwnames[] = {
47353 (char *) "self",(char *) "orient", NULL
47354 };
47355
47356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47358 if (!SWIG_IsOK(res1)) {
47359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47360 }
47361 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47362 ecode2 = SWIG_AsVal_int(obj1, &val2);
47363 if (!SWIG_IsOK(ecode2)) {
47364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47365 }
47366 arg2 = static_cast< int >(val2);
47367 {
47368 PyThreadState* __tstate = wxPyBeginAllowThreads();
47369 (arg1)->SetOrientation(arg2);
47370 wxPyEndAllowThreads(__tstate);
47371 if (PyErr_Occurred()) SWIG_fail;
47372 }
47373 resultobj = SWIG_Py_Void();
47374 return resultobj;
47375 fail:
47376 return NULL;
47377 }
47378
47379
47380 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47381 PyObject *obj;
47382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47383 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47384 return SWIG_Py_Void();
47385 }
47386
47387 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47388 return SWIG_Python_InitShadowInstance(args);
47389 }
47390
47391 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47392 PyObject *resultobj = 0;
47393 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47394 int arg2 = (int) wxHORIZONTAL ;
47395 wxStaticBoxSizer *result = 0 ;
47396 void *argp1 = 0 ;
47397 int res1 = 0 ;
47398 int val2 ;
47399 int ecode2 = 0 ;
47400 PyObject * obj0 = 0 ;
47401 PyObject * obj1 = 0 ;
47402 char * kwnames[] = {
47403 (char *) "box",(char *) "orient", NULL
47404 };
47405
47406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47408 if (!SWIG_IsOK(res1)) {
47409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47410 }
47411 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47412 if (obj1) {
47413 ecode2 = SWIG_AsVal_int(obj1, &val2);
47414 if (!SWIG_IsOK(ecode2)) {
47415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47416 }
47417 arg2 = static_cast< int >(val2);
47418 }
47419 {
47420 PyThreadState* __tstate = wxPyBeginAllowThreads();
47421 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47422 wxPyEndAllowThreads(__tstate);
47423 if (PyErr_Occurred()) SWIG_fail;
47424 }
47425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47426 return resultobj;
47427 fail:
47428 return NULL;
47429 }
47430
47431
47432 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47433 PyObject *resultobj = 0;
47434 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47435 wxStaticBox *result = 0 ;
47436 void *argp1 = 0 ;
47437 int res1 = 0 ;
47438 PyObject *swig_obj[1] ;
47439
47440 if (!args) SWIG_fail;
47441 swig_obj[0] = args;
47442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47443 if (!SWIG_IsOK(res1)) {
47444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47445 }
47446 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47447 {
47448 PyThreadState* __tstate = wxPyBeginAllowThreads();
47449 result = (wxStaticBox *)(arg1)->GetStaticBox();
47450 wxPyEndAllowThreads(__tstate);
47451 if (PyErr_Occurred()) SWIG_fail;
47452 }
47453 {
47454 resultobj = wxPyMake_wxObject(result, (bool)0);
47455 }
47456 return resultobj;
47457 fail:
47458 return NULL;
47459 }
47460
47461
47462 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47463 PyObject *obj;
47464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47465 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47466 return SWIG_Py_Void();
47467 }
47468
47469 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47470 return SWIG_Python_InitShadowInstance(args);
47471 }
47472
47473 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47474 PyObject *resultobj = 0;
47475 int arg1 = (int) 1 ;
47476 int arg2 = (int) 0 ;
47477 int arg3 = (int) 0 ;
47478 int arg4 = (int) 0 ;
47479 wxGridSizer *result = 0 ;
47480 int val1 ;
47481 int ecode1 = 0 ;
47482 int val2 ;
47483 int ecode2 = 0 ;
47484 int val3 ;
47485 int ecode3 = 0 ;
47486 int val4 ;
47487 int ecode4 = 0 ;
47488 PyObject * obj0 = 0 ;
47489 PyObject * obj1 = 0 ;
47490 PyObject * obj2 = 0 ;
47491 PyObject * obj3 = 0 ;
47492 char * kwnames[] = {
47493 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47494 };
47495
47496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47497 if (obj0) {
47498 ecode1 = SWIG_AsVal_int(obj0, &val1);
47499 if (!SWIG_IsOK(ecode1)) {
47500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47501 }
47502 arg1 = static_cast< int >(val1);
47503 }
47504 if (obj1) {
47505 ecode2 = SWIG_AsVal_int(obj1, &val2);
47506 if (!SWIG_IsOK(ecode2)) {
47507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47508 }
47509 arg2 = static_cast< int >(val2);
47510 }
47511 if (obj2) {
47512 ecode3 = SWIG_AsVal_int(obj2, &val3);
47513 if (!SWIG_IsOK(ecode3)) {
47514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47515 }
47516 arg3 = static_cast< int >(val3);
47517 }
47518 if (obj3) {
47519 ecode4 = SWIG_AsVal_int(obj3, &val4);
47520 if (!SWIG_IsOK(ecode4)) {
47521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47522 }
47523 arg4 = static_cast< int >(val4);
47524 }
47525 {
47526 PyThreadState* __tstate = wxPyBeginAllowThreads();
47527 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47528 wxPyEndAllowThreads(__tstate);
47529 if (PyErr_Occurred()) SWIG_fail;
47530 }
47531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47532 return resultobj;
47533 fail:
47534 return NULL;
47535 }
47536
47537
47538 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47539 PyObject *resultobj = 0;
47540 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47541 int arg2 ;
47542 void *argp1 = 0 ;
47543 int res1 = 0 ;
47544 int val2 ;
47545 int ecode2 = 0 ;
47546 PyObject * obj0 = 0 ;
47547 PyObject * obj1 = 0 ;
47548 char * kwnames[] = {
47549 (char *) "self",(char *) "cols", NULL
47550 };
47551
47552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47554 if (!SWIG_IsOK(res1)) {
47555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47556 }
47557 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47558 ecode2 = SWIG_AsVal_int(obj1, &val2);
47559 if (!SWIG_IsOK(ecode2)) {
47560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47561 }
47562 arg2 = static_cast< int >(val2);
47563 {
47564 PyThreadState* __tstate = wxPyBeginAllowThreads();
47565 (arg1)->SetCols(arg2);
47566 wxPyEndAllowThreads(__tstate);
47567 if (PyErr_Occurred()) SWIG_fail;
47568 }
47569 resultobj = SWIG_Py_Void();
47570 return resultobj;
47571 fail:
47572 return NULL;
47573 }
47574
47575
47576 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47577 PyObject *resultobj = 0;
47578 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47579 int arg2 ;
47580 void *argp1 = 0 ;
47581 int res1 = 0 ;
47582 int val2 ;
47583 int ecode2 = 0 ;
47584 PyObject * obj0 = 0 ;
47585 PyObject * obj1 = 0 ;
47586 char * kwnames[] = {
47587 (char *) "self",(char *) "rows", NULL
47588 };
47589
47590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47592 if (!SWIG_IsOK(res1)) {
47593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47594 }
47595 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47596 ecode2 = SWIG_AsVal_int(obj1, &val2);
47597 if (!SWIG_IsOK(ecode2)) {
47598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47599 }
47600 arg2 = static_cast< int >(val2);
47601 {
47602 PyThreadState* __tstate = wxPyBeginAllowThreads();
47603 (arg1)->SetRows(arg2);
47604 wxPyEndAllowThreads(__tstate);
47605 if (PyErr_Occurred()) SWIG_fail;
47606 }
47607 resultobj = SWIG_Py_Void();
47608 return resultobj;
47609 fail:
47610 return NULL;
47611 }
47612
47613
47614 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47615 PyObject *resultobj = 0;
47616 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47617 int arg2 ;
47618 void *argp1 = 0 ;
47619 int res1 = 0 ;
47620 int val2 ;
47621 int ecode2 = 0 ;
47622 PyObject * obj0 = 0 ;
47623 PyObject * obj1 = 0 ;
47624 char * kwnames[] = {
47625 (char *) "self",(char *) "gap", NULL
47626 };
47627
47628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47630 if (!SWIG_IsOK(res1)) {
47631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47632 }
47633 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47634 ecode2 = SWIG_AsVal_int(obj1, &val2);
47635 if (!SWIG_IsOK(ecode2)) {
47636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47637 }
47638 arg2 = static_cast< int >(val2);
47639 {
47640 PyThreadState* __tstate = wxPyBeginAllowThreads();
47641 (arg1)->SetVGap(arg2);
47642 wxPyEndAllowThreads(__tstate);
47643 if (PyErr_Occurred()) SWIG_fail;
47644 }
47645 resultobj = SWIG_Py_Void();
47646 return resultobj;
47647 fail:
47648 return NULL;
47649 }
47650
47651
47652 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47653 PyObject *resultobj = 0;
47654 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47655 int arg2 ;
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 *) "self",(char *) "gap", NULL
47664 };
47665
47666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47668 if (!SWIG_IsOK(res1)) {
47669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47670 }
47671 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47672 ecode2 = SWIG_AsVal_int(obj1, &val2);
47673 if (!SWIG_IsOK(ecode2)) {
47674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47675 }
47676 arg2 = static_cast< int >(val2);
47677 {
47678 PyThreadState* __tstate = wxPyBeginAllowThreads();
47679 (arg1)->SetHGap(arg2);
47680 wxPyEndAllowThreads(__tstate);
47681 if (PyErr_Occurred()) SWIG_fail;
47682 }
47683 resultobj = SWIG_Py_Void();
47684 return resultobj;
47685 fail:
47686 return NULL;
47687 }
47688
47689
47690 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47691 PyObject *resultobj = 0;
47692 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47693 int result;
47694 void *argp1 = 0 ;
47695 int res1 = 0 ;
47696 PyObject *swig_obj[1] ;
47697
47698 if (!args) SWIG_fail;
47699 swig_obj[0] = args;
47700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47701 if (!SWIG_IsOK(res1)) {
47702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47703 }
47704 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47705 {
47706 PyThreadState* __tstate = wxPyBeginAllowThreads();
47707 result = (int)(arg1)->GetCols();
47708 wxPyEndAllowThreads(__tstate);
47709 if (PyErr_Occurred()) SWIG_fail;
47710 }
47711 resultobj = SWIG_From_int(static_cast< int >(result));
47712 return resultobj;
47713 fail:
47714 return NULL;
47715 }
47716
47717
47718 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47719 PyObject *resultobj = 0;
47720 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47721 int result;
47722 void *argp1 = 0 ;
47723 int res1 = 0 ;
47724 PyObject *swig_obj[1] ;
47725
47726 if (!args) SWIG_fail;
47727 swig_obj[0] = args;
47728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47729 if (!SWIG_IsOK(res1)) {
47730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47731 }
47732 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 result = (int)(arg1)->GetRows();
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 resultobj = SWIG_From_int(static_cast< int >(result));
47740 return resultobj;
47741 fail:
47742 return NULL;
47743 }
47744
47745
47746 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47747 PyObject *resultobj = 0;
47748 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47749 int result;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 PyObject *swig_obj[1] ;
47753
47754 if (!args) SWIG_fail;
47755 swig_obj[0] = args;
47756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47757 if (!SWIG_IsOK(res1)) {
47758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47759 }
47760 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47761 {
47762 PyThreadState* __tstate = wxPyBeginAllowThreads();
47763 result = (int)(arg1)->GetVGap();
47764 wxPyEndAllowThreads(__tstate);
47765 if (PyErr_Occurred()) SWIG_fail;
47766 }
47767 resultobj = SWIG_From_int(static_cast< int >(result));
47768 return resultobj;
47769 fail:
47770 return NULL;
47771 }
47772
47773
47774 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47775 PyObject *resultobj = 0;
47776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47777 int result;
47778 void *argp1 = 0 ;
47779 int res1 = 0 ;
47780 PyObject *swig_obj[1] ;
47781
47782 if (!args) SWIG_fail;
47783 swig_obj[0] = args;
47784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47785 if (!SWIG_IsOK(res1)) {
47786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47787 }
47788 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47789 {
47790 PyThreadState* __tstate = wxPyBeginAllowThreads();
47791 result = (int)(arg1)->GetHGap();
47792 wxPyEndAllowThreads(__tstate);
47793 if (PyErr_Occurred()) SWIG_fail;
47794 }
47795 resultobj = SWIG_From_int(static_cast< int >(result));
47796 return resultobj;
47797 fail:
47798 return NULL;
47799 }
47800
47801
47802 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47803 PyObject *obj;
47804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47805 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47806 return SWIG_Py_Void();
47807 }
47808
47809 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47810 return SWIG_Python_InitShadowInstance(args);
47811 }
47812
47813 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47814 PyObject *resultobj = 0;
47815 int arg1 = (int) 1 ;
47816 int arg2 = (int) 0 ;
47817 int arg3 = (int) 0 ;
47818 int arg4 = (int) 0 ;
47819 wxFlexGridSizer *result = 0 ;
47820 int val1 ;
47821 int ecode1 = 0 ;
47822 int val2 ;
47823 int ecode2 = 0 ;
47824 int val3 ;
47825 int ecode3 = 0 ;
47826 int val4 ;
47827 int ecode4 = 0 ;
47828 PyObject * obj0 = 0 ;
47829 PyObject * obj1 = 0 ;
47830 PyObject * obj2 = 0 ;
47831 PyObject * obj3 = 0 ;
47832 char * kwnames[] = {
47833 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47834 };
47835
47836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47837 if (obj0) {
47838 ecode1 = SWIG_AsVal_int(obj0, &val1);
47839 if (!SWIG_IsOK(ecode1)) {
47840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47841 }
47842 arg1 = static_cast< int >(val1);
47843 }
47844 if (obj1) {
47845 ecode2 = SWIG_AsVal_int(obj1, &val2);
47846 if (!SWIG_IsOK(ecode2)) {
47847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47848 }
47849 arg2 = static_cast< int >(val2);
47850 }
47851 if (obj2) {
47852 ecode3 = SWIG_AsVal_int(obj2, &val3);
47853 if (!SWIG_IsOK(ecode3)) {
47854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47855 }
47856 arg3 = static_cast< int >(val3);
47857 }
47858 if (obj3) {
47859 ecode4 = SWIG_AsVal_int(obj3, &val4);
47860 if (!SWIG_IsOK(ecode4)) {
47861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47862 }
47863 arg4 = static_cast< int >(val4);
47864 }
47865 {
47866 PyThreadState* __tstate = wxPyBeginAllowThreads();
47867 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47868 wxPyEndAllowThreads(__tstate);
47869 if (PyErr_Occurred()) SWIG_fail;
47870 }
47871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47872 return resultobj;
47873 fail:
47874 return NULL;
47875 }
47876
47877
47878 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47879 PyObject *resultobj = 0;
47880 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47881 size_t arg2 ;
47882 int arg3 = (int) 0 ;
47883 void *argp1 = 0 ;
47884 int res1 = 0 ;
47885 size_t val2 ;
47886 int ecode2 = 0 ;
47887 int val3 ;
47888 int ecode3 = 0 ;
47889 PyObject * obj0 = 0 ;
47890 PyObject * obj1 = 0 ;
47891 PyObject * obj2 = 0 ;
47892 char * kwnames[] = {
47893 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47894 };
47895
47896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47898 if (!SWIG_IsOK(res1)) {
47899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47900 }
47901 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47902 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47903 if (!SWIG_IsOK(ecode2)) {
47904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47905 }
47906 arg2 = static_cast< size_t >(val2);
47907 if (obj2) {
47908 ecode3 = SWIG_AsVal_int(obj2, &val3);
47909 if (!SWIG_IsOK(ecode3)) {
47910 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47911 }
47912 arg3 = static_cast< int >(val3);
47913 }
47914 {
47915 PyThreadState* __tstate = wxPyBeginAllowThreads();
47916 (arg1)->AddGrowableRow(arg2,arg3);
47917 wxPyEndAllowThreads(__tstate);
47918 if (PyErr_Occurred()) SWIG_fail;
47919 }
47920 resultobj = SWIG_Py_Void();
47921 return resultobj;
47922 fail:
47923 return NULL;
47924 }
47925
47926
47927 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47928 PyObject *resultobj = 0;
47929 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47930 size_t arg2 ;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 size_t val2 ;
47934 int ecode2 = 0 ;
47935 PyObject * obj0 = 0 ;
47936 PyObject * obj1 = 0 ;
47937 char * kwnames[] = {
47938 (char *) "self",(char *) "idx", NULL
47939 };
47940
47941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47945 }
47946 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47947 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47948 if (!SWIG_IsOK(ecode2)) {
47949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47950 }
47951 arg2 = static_cast< size_t >(val2);
47952 {
47953 PyThreadState* __tstate = wxPyBeginAllowThreads();
47954 (arg1)->RemoveGrowableRow(arg2);
47955 wxPyEndAllowThreads(__tstate);
47956 if (PyErr_Occurred()) SWIG_fail;
47957 }
47958 resultobj = SWIG_Py_Void();
47959 return resultobj;
47960 fail:
47961 return NULL;
47962 }
47963
47964
47965 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47966 PyObject *resultobj = 0;
47967 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47968 size_t arg2 ;
47969 int arg3 = (int) 0 ;
47970 void *argp1 = 0 ;
47971 int res1 = 0 ;
47972 size_t val2 ;
47973 int ecode2 = 0 ;
47974 int val3 ;
47975 int ecode3 = 0 ;
47976 PyObject * obj0 = 0 ;
47977 PyObject * obj1 = 0 ;
47978 PyObject * obj2 = 0 ;
47979 char * kwnames[] = {
47980 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47981 };
47982
47983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47985 if (!SWIG_IsOK(res1)) {
47986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47987 }
47988 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47989 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47990 if (!SWIG_IsOK(ecode2)) {
47991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47992 }
47993 arg2 = static_cast< size_t >(val2);
47994 if (obj2) {
47995 ecode3 = SWIG_AsVal_int(obj2, &val3);
47996 if (!SWIG_IsOK(ecode3)) {
47997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47998 }
47999 arg3 = static_cast< int >(val3);
48000 }
48001 {
48002 PyThreadState* __tstate = wxPyBeginAllowThreads();
48003 (arg1)->AddGrowableCol(arg2,arg3);
48004 wxPyEndAllowThreads(__tstate);
48005 if (PyErr_Occurred()) SWIG_fail;
48006 }
48007 resultobj = SWIG_Py_Void();
48008 return resultobj;
48009 fail:
48010 return NULL;
48011 }
48012
48013
48014 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48015 PyObject *resultobj = 0;
48016 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48017 size_t arg2 ;
48018 void *argp1 = 0 ;
48019 int res1 = 0 ;
48020 size_t val2 ;
48021 int ecode2 = 0 ;
48022 PyObject * obj0 = 0 ;
48023 PyObject * obj1 = 0 ;
48024 char * kwnames[] = {
48025 (char *) "self",(char *) "idx", NULL
48026 };
48027
48028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48030 if (!SWIG_IsOK(res1)) {
48031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48032 }
48033 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48034 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48035 if (!SWIG_IsOK(ecode2)) {
48036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48037 }
48038 arg2 = static_cast< size_t >(val2);
48039 {
48040 PyThreadState* __tstate = wxPyBeginAllowThreads();
48041 (arg1)->RemoveGrowableCol(arg2);
48042 wxPyEndAllowThreads(__tstate);
48043 if (PyErr_Occurred()) SWIG_fail;
48044 }
48045 resultobj = SWIG_Py_Void();
48046 return resultobj;
48047 fail:
48048 return NULL;
48049 }
48050
48051
48052 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48053 PyObject *resultobj = 0;
48054 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48055 int arg2 ;
48056 void *argp1 = 0 ;
48057 int res1 = 0 ;
48058 int val2 ;
48059 int ecode2 = 0 ;
48060 PyObject * obj0 = 0 ;
48061 PyObject * obj1 = 0 ;
48062 char * kwnames[] = {
48063 (char *) "self",(char *) "direction", NULL
48064 };
48065
48066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48068 if (!SWIG_IsOK(res1)) {
48069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48070 }
48071 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48072 ecode2 = SWIG_AsVal_int(obj1, &val2);
48073 if (!SWIG_IsOK(ecode2)) {
48074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48075 }
48076 arg2 = static_cast< int >(val2);
48077 {
48078 PyThreadState* __tstate = wxPyBeginAllowThreads();
48079 (arg1)->SetFlexibleDirection(arg2);
48080 wxPyEndAllowThreads(__tstate);
48081 if (PyErr_Occurred()) SWIG_fail;
48082 }
48083 resultobj = SWIG_Py_Void();
48084 return resultobj;
48085 fail:
48086 return NULL;
48087 }
48088
48089
48090 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48091 PyObject *resultobj = 0;
48092 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48093 int result;
48094 void *argp1 = 0 ;
48095 int res1 = 0 ;
48096 PyObject *swig_obj[1] ;
48097
48098 if (!args) SWIG_fail;
48099 swig_obj[0] = args;
48100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48101 if (!SWIG_IsOK(res1)) {
48102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48103 }
48104 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48105 {
48106 PyThreadState* __tstate = wxPyBeginAllowThreads();
48107 result = (int)(arg1)->GetFlexibleDirection();
48108 wxPyEndAllowThreads(__tstate);
48109 if (PyErr_Occurred()) SWIG_fail;
48110 }
48111 resultobj = SWIG_From_int(static_cast< int >(result));
48112 return resultobj;
48113 fail:
48114 return NULL;
48115 }
48116
48117
48118 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48119 PyObject *resultobj = 0;
48120 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48121 wxFlexSizerGrowMode arg2 ;
48122 void *argp1 = 0 ;
48123 int res1 = 0 ;
48124 int val2 ;
48125 int ecode2 = 0 ;
48126 PyObject * obj0 = 0 ;
48127 PyObject * obj1 = 0 ;
48128 char * kwnames[] = {
48129 (char *) "self",(char *) "mode", NULL
48130 };
48131
48132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48134 if (!SWIG_IsOK(res1)) {
48135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48136 }
48137 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48138 ecode2 = SWIG_AsVal_int(obj1, &val2);
48139 if (!SWIG_IsOK(ecode2)) {
48140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48141 }
48142 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48143 {
48144 PyThreadState* __tstate = wxPyBeginAllowThreads();
48145 (arg1)->SetNonFlexibleGrowMode(arg2);
48146 wxPyEndAllowThreads(__tstate);
48147 if (PyErr_Occurred()) SWIG_fail;
48148 }
48149 resultobj = SWIG_Py_Void();
48150 return resultobj;
48151 fail:
48152 return NULL;
48153 }
48154
48155
48156 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48157 PyObject *resultobj = 0;
48158 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48159 wxFlexSizerGrowMode result;
48160 void *argp1 = 0 ;
48161 int res1 = 0 ;
48162 PyObject *swig_obj[1] ;
48163
48164 if (!args) SWIG_fail;
48165 swig_obj[0] = args;
48166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48167 if (!SWIG_IsOK(res1)) {
48168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48169 }
48170 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48171 {
48172 PyThreadState* __tstate = wxPyBeginAllowThreads();
48173 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48174 wxPyEndAllowThreads(__tstate);
48175 if (PyErr_Occurred()) SWIG_fail;
48176 }
48177 resultobj = SWIG_From_int(static_cast< int >(result));
48178 return resultobj;
48179 fail:
48180 return NULL;
48181 }
48182
48183
48184 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48185 PyObject *resultobj = 0;
48186 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48187 wxArrayInt *result = 0 ;
48188 void *argp1 = 0 ;
48189 int res1 = 0 ;
48190 PyObject *swig_obj[1] ;
48191
48192 if (!args) SWIG_fail;
48193 swig_obj[0] = args;
48194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48197 }
48198 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48199 {
48200 PyThreadState* __tstate = wxPyBeginAllowThreads();
48201 {
48202 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48203 result = (wxArrayInt *) &_result_ref;
48204 }
48205 wxPyEndAllowThreads(__tstate);
48206 if (PyErr_Occurred()) SWIG_fail;
48207 }
48208 {
48209 resultobj = PyList_New(0);
48210 size_t idx;
48211 for (idx = 0; idx < result->GetCount(); idx += 1) {
48212 PyObject* val = PyInt_FromLong( result->Item(idx) );
48213 PyList_Append(resultobj, val);
48214 Py_DECREF(val);
48215 }
48216 }
48217 return resultobj;
48218 fail:
48219 return NULL;
48220 }
48221
48222
48223 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48224 PyObject *resultobj = 0;
48225 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48226 wxArrayInt *result = 0 ;
48227 void *argp1 = 0 ;
48228 int res1 = 0 ;
48229 PyObject *swig_obj[1] ;
48230
48231 if (!args) SWIG_fail;
48232 swig_obj[0] = args;
48233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48234 if (!SWIG_IsOK(res1)) {
48235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48236 }
48237 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 {
48241 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48242 result = (wxArrayInt *) &_result_ref;
48243 }
48244 wxPyEndAllowThreads(__tstate);
48245 if (PyErr_Occurred()) SWIG_fail;
48246 }
48247 {
48248 resultobj = PyList_New(0);
48249 size_t idx;
48250 for (idx = 0; idx < result->GetCount(); idx += 1) {
48251 PyObject* val = PyInt_FromLong( result->Item(idx) );
48252 PyList_Append(resultobj, val);
48253 Py_DECREF(val);
48254 }
48255 }
48256 return resultobj;
48257 fail:
48258 return NULL;
48259 }
48260
48261
48262 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48263 PyObject *obj;
48264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48265 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48266 return SWIG_Py_Void();
48267 }
48268
48269 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48270 return SWIG_Python_InitShadowInstance(args);
48271 }
48272
48273 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48274 PyObject *resultobj = 0;
48275 wxStdDialogButtonSizer *result = 0 ;
48276
48277 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48294 wxButton *arg2 = (wxButton *) 0 ;
48295 void *argp1 = 0 ;
48296 int res1 = 0 ;
48297 void *argp2 = 0 ;
48298 int res2 = 0 ;
48299 PyObject * obj0 = 0 ;
48300 PyObject * obj1 = 0 ;
48301 char * kwnames[] = {
48302 (char *) "self",(char *) "button", NULL
48303 };
48304
48305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48307 if (!SWIG_IsOK(res1)) {
48308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48309 }
48310 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48312 if (!SWIG_IsOK(res2)) {
48313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48314 }
48315 arg2 = reinterpret_cast< wxButton * >(argp2);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 (arg1)->AddButton(arg2);
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 resultobj = SWIG_Py_Void();
48323 return resultobj;
48324 fail:
48325 return NULL;
48326 }
48327
48328
48329 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48330 PyObject *resultobj = 0;
48331 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48332 void *argp1 = 0 ;
48333 int res1 = 0 ;
48334 PyObject *swig_obj[1] ;
48335
48336 if (!args) SWIG_fail;
48337 swig_obj[0] = args;
48338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48339 if (!SWIG_IsOK(res1)) {
48340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48341 }
48342 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48343 {
48344 PyThreadState* __tstate = wxPyBeginAllowThreads();
48345 (arg1)->Realize();
48346 wxPyEndAllowThreads(__tstate);
48347 if (PyErr_Occurred()) SWIG_fail;
48348 }
48349 resultobj = SWIG_Py_Void();
48350 return resultobj;
48351 fail:
48352 return NULL;
48353 }
48354
48355
48356 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48357 PyObject *resultobj = 0;
48358 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48359 wxButton *arg2 = (wxButton *) 0 ;
48360 void *argp1 = 0 ;
48361 int res1 = 0 ;
48362 void *argp2 = 0 ;
48363 int res2 = 0 ;
48364 PyObject * obj0 = 0 ;
48365 PyObject * obj1 = 0 ;
48366 char * kwnames[] = {
48367 (char *) "self",(char *) "button", NULL
48368 };
48369
48370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48374 }
48375 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48377 if (!SWIG_IsOK(res2)) {
48378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48379 }
48380 arg2 = reinterpret_cast< wxButton * >(argp2);
48381 {
48382 PyThreadState* __tstate = wxPyBeginAllowThreads();
48383 (arg1)->SetAffirmativeButton(arg2);
48384 wxPyEndAllowThreads(__tstate);
48385 if (PyErr_Occurred()) SWIG_fail;
48386 }
48387 resultobj = SWIG_Py_Void();
48388 return resultobj;
48389 fail:
48390 return NULL;
48391 }
48392
48393
48394 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48395 PyObject *resultobj = 0;
48396 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48397 wxButton *arg2 = (wxButton *) 0 ;
48398 void *argp1 = 0 ;
48399 int res1 = 0 ;
48400 void *argp2 = 0 ;
48401 int res2 = 0 ;
48402 PyObject * obj0 = 0 ;
48403 PyObject * obj1 = 0 ;
48404 char * kwnames[] = {
48405 (char *) "self",(char *) "button", NULL
48406 };
48407
48408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48410 if (!SWIG_IsOK(res1)) {
48411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48412 }
48413 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48414 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48415 if (!SWIG_IsOK(res2)) {
48416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48417 }
48418 arg2 = reinterpret_cast< wxButton * >(argp2);
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 (arg1)->SetNegativeButton(arg2);
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_Py_Void();
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48433 PyObject *resultobj = 0;
48434 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48435 wxButton *arg2 = (wxButton *) 0 ;
48436 void *argp1 = 0 ;
48437 int res1 = 0 ;
48438 void *argp2 = 0 ;
48439 int res2 = 0 ;
48440 PyObject * obj0 = 0 ;
48441 PyObject * obj1 = 0 ;
48442 char * kwnames[] = {
48443 (char *) "self",(char *) "button", NULL
48444 };
48445
48446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48448 if (!SWIG_IsOK(res1)) {
48449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48450 }
48451 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48453 if (!SWIG_IsOK(res2)) {
48454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48455 }
48456 arg2 = reinterpret_cast< wxButton * >(argp2);
48457 {
48458 PyThreadState* __tstate = wxPyBeginAllowThreads();
48459 (arg1)->SetCancelButton(arg2);
48460 wxPyEndAllowThreads(__tstate);
48461 if (PyErr_Occurred()) SWIG_fail;
48462 }
48463 resultobj = SWIG_Py_Void();
48464 return resultobj;
48465 fail:
48466 return NULL;
48467 }
48468
48469
48470 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48471 PyObject *resultobj = 0;
48472 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48473 wxButton *result = 0 ;
48474 void *argp1 = 0 ;
48475 int res1 = 0 ;
48476 PyObject *swig_obj[1] ;
48477
48478 if (!args) SWIG_fail;
48479 swig_obj[0] = args;
48480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48481 if (!SWIG_IsOK(res1)) {
48482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48483 }
48484 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48485 {
48486 PyThreadState* __tstate = wxPyBeginAllowThreads();
48487 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48488 wxPyEndAllowThreads(__tstate);
48489 if (PyErr_Occurred()) SWIG_fail;
48490 }
48491 {
48492 resultobj = wxPyMake_wxObject(result, (bool)0);
48493 }
48494 return resultobj;
48495 fail:
48496 return NULL;
48497 }
48498
48499
48500 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48501 PyObject *resultobj = 0;
48502 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48503 wxButton *result = 0 ;
48504 void *argp1 = 0 ;
48505 int res1 = 0 ;
48506 PyObject *swig_obj[1] ;
48507
48508 if (!args) SWIG_fail;
48509 swig_obj[0] = args;
48510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48511 if (!SWIG_IsOK(res1)) {
48512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48513 }
48514 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48515 {
48516 PyThreadState* __tstate = wxPyBeginAllowThreads();
48517 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48518 wxPyEndAllowThreads(__tstate);
48519 if (PyErr_Occurred()) SWIG_fail;
48520 }
48521 {
48522 resultobj = wxPyMake_wxObject(result, (bool)0);
48523 }
48524 return resultobj;
48525 fail:
48526 return NULL;
48527 }
48528
48529
48530 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48531 PyObject *resultobj = 0;
48532 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48533 wxButton *result = 0 ;
48534 void *argp1 = 0 ;
48535 int res1 = 0 ;
48536 PyObject *swig_obj[1] ;
48537
48538 if (!args) SWIG_fail;
48539 swig_obj[0] = args;
48540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48541 if (!SWIG_IsOK(res1)) {
48542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48543 }
48544 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48545 {
48546 PyThreadState* __tstate = wxPyBeginAllowThreads();
48547 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48548 wxPyEndAllowThreads(__tstate);
48549 if (PyErr_Occurred()) SWIG_fail;
48550 }
48551 {
48552 resultobj = wxPyMake_wxObject(result, (bool)0);
48553 }
48554 return resultobj;
48555 fail:
48556 return NULL;
48557 }
48558
48559
48560 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48561 PyObject *resultobj = 0;
48562 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48563 wxButton *result = 0 ;
48564 void *argp1 = 0 ;
48565 int res1 = 0 ;
48566 PyObject *swig_obj[1] ;
48567
48568 if (!args) SWIG_fail;
48569 swig_obj[0] = args;
48570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48571 if (!SWIG_IsOK(res1)) {
48572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48573 }
48574 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48575 {
48576 PyThreadState* __tstate = wxPyBeginAllowThreads();
48577 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48578 wxPyEndAllowThreads(__tstate);
48579 if (PyErr_Occurred()) SWIG_fail;
48580 }
48581 {
48582 resultobj = wxPyMake_wxObject(result, (bool)0);
48583 }
48584 return resultobj;
48585 fail:
48586 return NULL;
48587 }
48588
48589
48590 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48591 PyObject *resultobj = 0;
48592 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48593 wxButton *result = 0 ;
48594 void *argp1 = 0 ;
48595 int res1 = 0 ;
48596 PyObject *swig_obj[1] ;
48597
48598 if (!args) SWIG_fail;
48599 swig_obj[0] = args;
48600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48601 if (!SWIG_IsOK(res1)) {
48602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48603 }
48604 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48605 {
48606 PyThreadState* __tstate = wxPyBeginAllowThreads();
48607 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48608 wxPyEndAllowThreads(__tstate);
48609 if (PyErr_Occurred()) SWIG_fail;
48610 }
48611 {
48612 resultobj = wxPyMake_wxObject(result, (bool)0);
48613 }
48614 return resultobj;
48615 fail:
48616 return NULL;
48617 }
48618
48619
48620 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48621 PyObject *obj;
48622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48623 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48624 return SWIG_Py_Void();
48625 }
48626
48627 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48628 return SWIG_Python_InitShadowInstance(args);
48629 }
48630
48631 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48632 PyObject *resultobj = 0;
48633 int arg1 = (int) 0 ;
48634 int arg2 = (int) 0 ;
48635 wxGBPosition *result = 0 ;
48636 int val1 ;
48637 int ecode1 = 0 ;
48638 int val2 ;
48639 int ecode2 = 0 ;
48640 PyObject * obj0 = 0 ;
48641 PyObject * obj1 = 0 ;
48642 char * kwnames[] = {
48643 (char *) "row",(char *) "col", NULL
48644 };
48645
48646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48647 if (obj0) {
48648 ecode1 = SWIG_AsVal_int(obj0, &val1);
48649 if (!SWIG_IsOK(ecode1)) {
48650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48651 }
48652 arg1 = static_cast< int >(val1);
48653 }
48654 if (obj1) {
48655 ecode2 = SWIG_AsVal_int(obj1, &val2);
48656 if (!SWIG_IsOK(ecode2)) {
48657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48658 }
48659 arg2 = static_cast< int >(val2);
48660 }
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48664 wxPyEndAllowThreads(__tstate);
48665 if (PyErr_Occurred()) SWIG_fail;
48666 }
48667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48668 return resultobj;
48669 fail:
48670 return NULL;
48671 }
48672
48673
48674 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48675 PyObject *resultobj = 0;
48676 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48677 void *argp1 = 0 ;
48678 int res1 = 0 ;
48679 PyObject *swig_obj[1] ;
48680
48681 if (!args) SWIG_fail;
48682 swig_obj[0] = args;
48683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48684 if (!SWIG_IsOK(res1)) {
48685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48686 }
48687 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48688 {
48689 PyThreadState* __tstate = wxPyBeginAllowThreads();
48690 delete arg1;
48691
48692 wxPyEndAllowThreads(__tstate);
48693 if (PyErr_Occurred()) SWIG_fail;
48694 }
48695 resultobj = SWIG_Py_Void();
48696 return resultobj;
48697 fail:
48698 return NULL;
48699 }
48700
48701
48702 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48703 PyObject *resultobj = 0;
48704 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48705 int result;
48706 void *argp1 = 0 ;
48707 int res1 = 0 ;
48708 PyObject *swig_obj[1] ;
48709
48710 if (!args) SWIG_fail;
48711 swig_obj[0] = args;
48712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48713 if (!SWIG_IsOK(res1)) {
48714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48715 }
48716 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48717 {
48718 PyThreadState* __tstate = wxPyBeginAllowThreads();
48719 result = (int)((wxGBPosition const *)arg1)->GetRow();
48720 wxPyEndAllowThreads(__tstate);
48721 if (PyErr_Occurred()) SWIG_fail;
48722 }
48723 resultobj = SWIG_From_int(static_cast< int >(result));
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48731 PyObject *resultobj = 0;
48732 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48733 int result;
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_wxGBPosition, 0 | 0 );
48741 if (!SWIG_IsOK(res1)) {
48742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48743 }
48744 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48745 {
48746 PyThreadState* __tstate = wxPyBeginAllowThreads();
48747 result = (int)((wxGBPosition const *)arg1)->GetCol();
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 resultobj = SWIG_From_int(static_cast< int >(result));
48752 return resultobj;
48753 fail:
48754 return NULL;
48755 }
48756
48757
48758 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48759 PyObject *resultobj = 0;
48760 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48761 int arg2 ;
48762 void *argp1 = 0 ;
48763 int res1 = 0 ;
48764 int val2 ;
48765 int ecode2 = 0 ;
48766 PyObject * obj0 = 0 ;
48767 PyObject * obj1 = 0 ;
48768 char * kwnames[] = {
48769 (char *) "self",(char *) "row", NULL
48770 };
48771
48772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48774 if (!SWIG_IsOK(res1)) {
48775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48776 }
48777 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48778 ecode2 = SWIG_AsVal_int(obj1, &val2);
48779 if (!SWIG_IsOK(ecode2)) {
48780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48781 }
48782 arg2 = static_cast< int >(val2);
48783 {
48784 PyThreadState* __tstate = wxPyBeginAllowThreads();
48785 (arg1)->SetRow(arg2);
48786 wxPyEndAllowThreads(__tstate);
48787 if (PyErr_Occurred()) SWIG_fail;
48788 }
48789 resultobj = SWIG_Py_Void();
48790 return resultobj;
48791 fail:
48792 return NULL;
48793 }
48794
48795
48796 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48797 PyObject *resultobj = 0;
48798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48799 int arg2 ;
48800 void *argp1 = 0 ;
48801 int res1 = 0 ;
48802 int val2 ;
48803 int ecode2 = 0 ;
48804 PyObject * obj0 = 0 ;
48805 PyObject * obj1 = 0 ;
48806 char * kwnames[] = {
48807 (char *) "self",(char *) "col", NULL
48808 };
48809
48810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48812 if (!SWIG_IsOK(res1)) {
48813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48814 }
48815 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48816 ecode2 = SWIG_AsVal_int(obj1, &val2);
48817 if (!SWIG_IsOK(ecode2)) {
48818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48819 }
48820 arg2 = static_cast< int >(val2);
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 (arg1)->SetCol(arg2);
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_Py_Void();
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48835 PyObject *resultobj = 0;
48836 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48837 PyObject *arg2 = (PyObject *) 0 ;
48838 bool result;
48839 void *argp1 = 0 ;
48840 int res1 = 0 ;
48841 PyObject * obj0 = 0 ;
48842 PyObject * obj1 = 0 ;
48843 char * kwnames[] = {
48844 (char *) "self",(char *) "other", NULL
48845 };
48846
48847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48849 if (!SWIG_IsOK(res1)) {
48850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48851 }
48852 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48853 arg2 = obj1;
48854 {
48855 result = (bool)wxGBPosition___eq__(arg1,arg2);
48856 if (PyErr_Occurred()) SWIG_fail;
48857 }
48858 {
48859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48860 }
48861 return resultobj;
48862 fail:
48863 return NULL;
48864 }
48865
48866
48867 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48868 PyObject *resultobj = 0;
48869 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48870 PyObject *arg2 = (PyObject *) 0 ;
48871 bool result;
48872 void *argp1 = 0 ;
48873 int res1 = 0 ;
48874 PyObject * obj0 = 0 ;
48875 PyObject * obj1 = 0 ;
48876 char * kwnames[] = {
48877 (char *) "self",(char *) "other", NULL
48878 };
48879
48880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48882 if (!SWIG_IsOK(res1)) {
48883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48884 }
48885 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48886 arg2 = obj1;
48887 {
48888 result = (bool)wxGBPosition___ne__(arg1,arg2);
48889 if (PyErr_Occurred()) SWIG_fail;
48890 }
48891 {
48892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48893 }
48894 return resultobj;
48895 fail:
48896 return NULL;
48897 }
48898
48899
48900 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48901 PyObject *resultobj = 0;
48902 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48903 int arg2 = (int) 0 ;
48904 int arg3 = (int) 0 ;
48905 void *argp1 = 0 ;
48906 int res1 = 0 ;
48907 int val2 ;
48908 int ecode2 = 0 ;
48909 int val3 ;
48910 int ecode3 = 0 ;
48911 PyObject * obj0 = 0 ;
48912 PyObject * obj1 = 0 ;
48913 PyObject * obj2 = 0 ;
48914 char * kwnames[] = {
48915 (char *) "self",(char *) "row",(char *) "col", NULL
48916 };
48917
48918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48920 if (!SWIG_IsOK(res1)) {
48921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48922 }
48923 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48924 if (obj1) {
48925 ecode2 = SWIG_AsVal_int(obj1, &val2);
48926 if (!SWIG_IsOK(ecode2)) {
48927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48928 }
48929 arg2 = static_cast< int >(val2);
48930 }
48931 if (obj2) {
48932 ecode3 = SWIG_AsVal_int(obj2, &val3);
48933 if (!SWIG_IsOK(ecode3)) {
48934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48935 }
48936 arg3 = static_cast< int >(val3);
48937 }
48938 {
48939 PyThreadState* __tstate = wxPyBeginAllowThreads();
48940 wxGBPosition_Set(arg1,arg2,arg3);
48941 wxPyEndAllowThreads(__tstate);
48942 if (PyErr_Occurred()) SWIG_fail;
48943 }
48944 resultobj = SWIG_Py_Void();
48945 return resultobj;
48946 fail:
48947 return NULL;
48948 }
48949
48950
48951 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48952 PyObject *resultobj = 0;
48953 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48954 PyObject *result = 0 ;
48955 void *argp1 = 0 ;
48956 int res1 = 0 ;
48957 PyObject *swig_obj[1] ;
48958
48959 if (!args) SWIG_fail;
48960 swig_obj[0] = args;
48961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48962 if (!SWIG_IsOK(res1)) {
48963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48964 }
48965 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48966 {
48967 PyThreadState* __tstate = wxPyBeginAllowThreads();
48968 result = (PyObject *)wxGBPosition_Get(arg1);
48969 wxPyEndAllowThreads(__tstate);
48970 if (PyErr_Occurred()) SWIG_fail;
48971 }
48972 resultobj = result;
48973 return resultobj;
48974 fail:
48975 return NULL;
48976 }
48977
48978
48979 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48980 PyObject *obj;
48981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48982 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48983 return SWIG_Py_Void();
48984 }
48985
48986 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 return SWIG_Python_InitShadowInstance(args);
48988 }
48989
48990 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48991 PyObject *resultobj = 0;
48992 int arg1 = (int) 1 ;
48993 int arg2 = (int) 1 ;
48994 wxGBSpan *result = 0 ;
48995 int val1 ;
48996 int ecode1 = 0 ;
48997 int val2 ;
48998 int ecode2 = 0 ;
48999 PyObject * obj0 = 0 ;
49000 PyObject * obj1 = 0 ;
49001 char * kwnames[] = {
49002 (char *) "rowspan",(char *) "colspan", NULL
49003 };
49004
49005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49006 if (obj0) {
49007 ecode1 = SWIG_AsVal_int(obj0, &val1);
49008 if (!SWIG_IsOK(ecode1)) {
49009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49010 }
49011 arg1 = static_cast< int >(val1);
49012 }
49013 if (obj1) {
49014 ecode2 = SWIG_AsVal_int(obj1, &val2);
49015 if (!SWIG_IsOK(ecode2)) {
49016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49017 }
49018 arg2 = static_cast< int >(val2);
49019 }
49020 {
49021 PyThreadState* __tstate = wxPyBeginAllowThreads();
49022 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49023 wxPyEndAllowThreads(__tstate);
49024 if (PyErr_Occurred()) SWIG_fail;
49025 }
49026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49027 return resultobj;
49028 fail:
49029 return NULL;
49030 }
49031
49032
49033 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49034 PyObject *resultobj = 0;
49035 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49036 void *argp1 = 0 ;
49037 int res1 = 0 ;
49038 PyObject *swig_obj[1] ;
49039
49040 if (!args) SWIG_fail;
49041 swig_obj[0] = args;
49042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49043 if (!SWIG_IsOK(res1)) {
49044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49045 }
49046 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49047 {
49048 PyThreadState* __tstate = wxPyBeginAllowThreads();
49049 delete arg1;
49050
49051 wxPyEndAllowThreads(__tstate);
49052 if (PyErr_Occurred()) SWIG_fail;
49053 }
49054 resultobj = SWIG_Py_Void();
49055 return resultobj;
49056 fail:
49057 return NULL;
49058 }
49059
49060
49061 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49062 PyObject *resultobj = 0;
49063 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49064 int result;
49065 void *argp1 = 0 ;
49066 int res1 = 0 ;
49067 PyObject *swig_obj[1] ;
49068
49069 if (!args) SWIG_fail;
49070 swig_obj[0] = args;
49071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49072 if (!SWIG_IsOK(res1)) {
49073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49074 }
49075 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49076 {
49077 PyThreadState* __tstate = wxPyBeginAllowThreads();
49078 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49079 wxPyEndAllowThreads(__tstate);
49080 if (PyErr_Occurred()) SWIG_fail;
49081 }
49082 resultobj = SWIG_From_int(static_cast< int >(result));
49083 return resultobj;
49084 fail:
49085 return NULL;
49086 }
49087
49088
49089 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49090 PyObject *resultobj = 0;
49091 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49092 int result;
49093 void *argp1 = 0 ;
49094 int res1 = 0 ;
49095 PyObject *swig_obj[1] ;
49096
49097 if (!args) SWIG_fail;
49098 swig_obj[0] = args;
49099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49100 if (!SWIG_IsOK(res1)) {
49101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49102 }
49103 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49104 {
49105 PyThreadState* __tstate = wxPyBeginAllowThreads();
49106 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49107 wxPyEndAllowThreads(__tstate);
49108 if (PyErr_Occurred()) SWIG_fail;
49109 }
49110 resultobj = SWIG_From_int(static_cast< int >(result));
49111 return resultobj;
49112 fail:
49113 return NULL;
49114 }
49115
49116
49117 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49118 PyObject *resultobj = 0;
49119 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49120 int arg2 ;
49121 void *argp1 = 0 ;
49122 int res1 = 0 ;
49123 int val2 ;
49124 int ecode2 = 0 ;
49125 PyObject * obj0 = 0 ;
49126 PyObject * obj1 = 0 ;
49127 char * kwnames[] = {
49128 (char *) "self",(char *) "rowspan", NULL
49129 };
49130
49131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49133 if (!SWIG_IsOK(res1)) {
49134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49135 }
49136 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49137 ecode2 = SWIG_AsVal_int(obj1, &val2);
49138 if (!SWIG_IsOK(ecode2)) {
49139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49140 }
49141 arg2 = static_cast< int >(val2);
49142 {
49143 PyThreadState* __tstate = wxPyBeginAllowThreads();
49144 (arg1)->SetRowspan(arg2);
49145 wxPyEndAllowThreads(__tstate);
49146 if (PyErr_Occurred()) SWIG_fail;
49147 }
49148 resultobj = SWIG_Py_Void();
49149 return resultobj;
49150 fail:
49151 return NULL;
49152 }
49153
49154
49155 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49156 PyObject *resultobj = 0;
49157 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49158 int arg2 ;
49159 void *argp1 = 0 ;
49160 int res1 = 0 ;
49161 int val2 ;
49162 int ecode2 = 0 ;
49163 PyObject * obj0 = 0 ;
49164 PyObject * obj1 = 0 ;
49165 char * kwnames[] = {
49166 (char *) "self",(char *) "colspan", NULL
49167 };
49168
49169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49171 if (!SWIG_IsOK(res1)) {
49172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49173 }
49174 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49175 ecode2 = SWIG_AsVal_int(obj1, &val2);
49176 if (!SWIG_IsOK(ecode2)) {
49177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49178 }
49179 arg2 = static_cast< int >(val2);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 (arg1)->SetColspan(arg2);
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = SWIG_Py_Void();
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49194 PyObject *resultobj = 0;
49195 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49196 PyObject *arg2 = (PyObject *) 0 ;
49197 bool result;
49198 void *argp1 = 0 ;
49199 int res1 = 0 ;
49200 PyObject * obj0 = 0 ;
49201 PyObject * obj1 = 0 ;
49202 char * kwnames[] = {
49203 (char *) "self",(char *) "other", NULL
49204 };
49205
49206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49208 if (!SWIG_IsOK(res1)) {
49209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49210 }
49211 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49212 arg2 = obj1;
49213 {
49214 result = (bool)wxGBSpan___eq__(arg1,arg2);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 {
49218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49219 }
49220 return resultobj;
49221 fail:
49222 return NULL;
49223 }
49224
49225
49226 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49227 PyObject *resultobj = 0;
49228 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49229 PyObject *arg2 = (PyObject *) 0 ;
49230 bool result;
49231 void *argp1 = 0 ;
49232 int res1 = 0 ;
49233 PyObject * obj0 = 0 ;
49234 PyObject * obj1 = 0 ;
49235 char * kwnames[] = {
49236 (char *) "self",(char *) "other", NULL
49237 };
49238
49239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49241 if (!SWIG_IsOK(res1)) {
49242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49243 }
49244 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49245 arg2 = obj1;
49246 {
49247 result = (bool)wxGBSpan___ne__(arg1,arg2);
49248 if (PyErr_Occurred()) SWIG_fail;
49249 }
49250 {
49251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49252 }
49253 return resultobj;
49254 fail:
49255 return NULL;
49256 }
49257
49258
49259 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49260 PyObject *resultobj = 0;
49261 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49262 int arg2 = (int) 1 ;
49263 int arg3 = (int) 1 ;
49264 void *argp1 = 0 ;
49265 int res1 = 0 ;
49266 int val2 ;
49267 int ecode2 = 0 ;
49268 int val3 ;
49269 int ecode3 = 0 ;
49270 PyObject * obj0 = 0 ;
49271 PyObject * obj1 = 0 ;
49272 PyObject * obj2 = 0 ;
49273 char * kwnames[] = {
49274 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49275 };
49276
49277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49279 if (!SWIG_IsOK(res1)) {
49280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49281 }
49282 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49283 if (obj1) {
49284 ecode2 = SWIG_AsVal_int(obj1, &val2);
49285 if (!SWIG_IsOK(ecode2)) {
49286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49287 }
49288 arg2 = static_cast< int >(val2);
49289 }
49290 if (obj2) {
49291 ecode3 = SWIG_AsVal_int(obj2, &val3);
49292 if (!SWIG_IsOK(ecode3)) {
49293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49294 }
49295 arg3 = static_cast< int >(val3);
49296 }
49297 {
49298 PyThreadState* __tstate = wxPyBeginAllowThreads();
49299 wxGBSpan_Set(arg1,arg2,arg3);
49300 wxPyEndAllowThreads(__tstate);
49301 if (PyErr_Occurred()) SWIG_fail;
49302 }
49303 resultobj = SWIG_Py_Void();
49304 return resultobj;
49305 fail:
49306 return NULL;
49307 }
49308
49309
49310 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49311 PyObject *resultobj = 0;
49312 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49313 PyObject *result = 0 ;
49314 void *argp1 = 0 ;
49315 int res1 = 0 ;
49316 PyObject *swig_obj[1] ;
49317
49318 if (!args) SWIG_fail;
49319 swig_obj[0] = args;
49320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49321 if (!SWIG_IsOK(res1)) {
49322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49323 }
49324 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49325 {
49326 PyThreadState* __tstate = wxPyBeginAllowThreads();
49327 result = (PyObject *)wxGBSpan_Get(arg1);
49328 wxPyEndAllowThreads(__tstate);
49329 if (PyErr_Occurred()) SWIG_fail;
49330 }
49331 resultobj = result;
49332 return resultobj;
49333 fail:
49334 return NULL;
49335 }
49336
49337
49338 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49339 PyObject *obj;
49340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49341 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49342 return SWIG_Py_Void();
49343 }
49344
49345 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49346 return SWIG_Python_InitShadowInstance(args);
49347 }
49348
49349 SWIGINTERN int DefaultSpan_set(PyObject *) {
49350 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49351 return 1;
49352 }
49353
49354
49355 SWIGINTERN PyObject *DefaultSpan_get(void) {
49356 PyObject *pyobj = 0;
49357
49358 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49359 return pyobj;
49360 }
49361
49362
49363 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49364 PyObject *resultobj = 0;
49365 wxGBSizerItem *result = 0 ;
49366
49367 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 result = (wxGBSizerItem *)new wxGBSizerItem();
49371 wxPyEndAllowThreads(__tstate);
49372 if (PyErr_Occurred()) SWIG_fail;
49373 }
49374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49375 return resultobj;
49376 fail:
49377 return NULL;
49378 }
49379
49380
49381 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49382 PyObject *resultobj = 0;
49383 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49384 void *argp1 = 0 ;
49385 int res1 = 0 ;
49386 PyObject *swig_obj[1] ;
49387
49388 if (!args) SWIG_fail;
49389 swig_obj[0] = args;
49390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49391 if (!SWIG_IsOK(res1)) {
49392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49393 }
49394 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49395 {
49396 PyThreadState* __tstate = wxPyBeginAllowThreads();
49397 delete arg1;
49398
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 resultobj = SWIG_Py_Void();
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49410 PyObject *resultobj = 0;
49411 wxWindow *arg1 = (wxWindow *) 0 ;
49412 wxGBPosition *arg2 = 0 ;
49413 wxGBSpan *arg3 = 0 ;
49414 int arg4 ;
49415 int arg5 ;
49416 PyObject *arg6 = (PyObject *) NULL ;
49417 wxGBSizerItem *result = 0 ;
49418 void *argp1 = 0 ;
49419 int res1 = 0 ;
49420 wxGBPosition temp2 ;
49421 wxGBSpan temp3 ;
49422 int val4 ;
49423 int ecode4 = 0 ;
49424 int val5 ;
49425 int ecode5 = 0 ;
49426 PyObject * obj0 = 0 ;
49427 PyObject * obj1 = 0 ;
49428 PyObject * obj2 = 0 ;
49429 PyObject * obj3 = 0 ;
49430 PyObject * obj4 = 0 ;
49431 PyObject * obj5 = 0 ;
49432 char * kwnames[] = {
49433 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49434 };
49435
49436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49438 if (!SWIG_IsOK(res1)) {
49439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49440 }
49441 arg1 = reinterpret_cast< wxWindow * >(argp1);
49442 {
49443 arg2 = &temp2;
49444 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49445 }
49446 {
49447 arg3 = &temp3;
49448 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49449 }
49450 ecode4 = SWIG_AsVal_int(obj3, &val4);
49451 if (!SWIG_IsOK(ecode4)) {
49452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49453 }
49454 arg4 = static_cast< int >(val4);
49455 ecode5 = SWIG_AsVal_int(obj4, &val5);
49456 if (!SWIG_IsOK(ecode5)) {
49457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49458 }
49459 arg5 = static_cast< int >(val5);
49460 if (obj5) {
49461 arg6 = obj5;
49462 }
49463 {
49464 PyThreadState* __tstate = wxPyBeginAllowThreads();
49465 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49466 wxPyEndAllowThreads(__tstate);
49467 if (PyErr_Occurred()) SWIG_fail;
49468 }
49469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49470 return resultobj;
49471 fail:
49472 return NULL;
49473 }
49474
49475
49476 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49477 PyObject *resultobj = 0;
49478 wxSizer *arg1 = (wxSizer *) 0 ;
49479 wxGBPosition *arg2 = 0 ;
49480 wxGBSpan *arg3 = 0 ;
49481 int arg4 ;
49482 int arg5 ;
49483 PyObject *arg6 = (PyObject *) NULL ;
49484 wxGBSizerItem *result = 0 ;
49485 int res1 = 0 ;
49486 wxGBPosition temp2 ;
49487 wxGBSpan temp3 ;
49488 int val4 ;
49489 int ecode4 = 0 ;
49490 int val5 ;
49491 int ecode5 = 0 ;
49492 PyObject * obj0 = 0 ;
49493 PyObject * obj1 = 0 ;
49494 PyObject * obj2 = 0 ;
49495 PyObject * obj3 = 0 ;
49496 PyObject * obj4 = 0 ;
49497 PyObject * obj5 = 0 ;
49498 char * kwnames[] = {
49499 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49500 };
49501
49502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49503 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49504 if (!SWIG_IsOK(res1)) {
49505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49506 }
49507 {
49508 arg2 = &temp2;
49509 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49510 }
49511 {
49512 arg3 = &temp3;
49513 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49514 }
49515 ecode4 = SWIG_AsVal_int(obj3, &val4);
49516 if (!SWIG_IsOK(ecode4)) {
49517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49518 }
49519 arg4 = static_cast< int >(val4);
49520 ecode5 = SWIG_AsVal_int(obj4, &val5);
49521 if (!SWIG_IsOK(ecode5)) {
49522 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49523 }
49524 arg5 = static_cast< int >(val5);
49525 if (obj5) {
49526 arg6 = obj5;
49527 }
49528 {
49529 PyThreadState* __tstate = wxPyBeginAllowThreads();
49530 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49531 wxPyEndAllowThreads(__tstate);
49532 if (PyErr_Occurred()) SWIG_fail;
49533 }
49534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49535 return resultobj;
49536 fail:
49537 return NULL;
49538 }
49539
49540
49541 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49542 PyObject *resultobj = 0;
49543 int arg1 ;
49544 int arg2 ;
49545 wxGBPosition *arg3 = 0 ;
49546 wxGBSpan *arg4 = 0 ;
49547 int arg5 ;
49548 int arg6 ;
49549 PyObject *arg7 = (PyObject *) NULL ;
49550 wxGBSizerItem *result = 0 ;
49551 int val1 ;
49552 int ecode1 = 0 ;
49553 int val2 ;
49554 int ecode2 = 0 ;
49555 wxGBPosition temp3 ;
49556 wxGBSpan temp4 ;
49557 int val5 ;
49558 int ecode5 = 0 ;
49559 int val6 ;
49560 int ecode6 = 0 ;
49561 PyObject * obj0 = 0 ;
49562 PyObject * obj1 = 0 ;
49563 PyObject * obj2 = 0 ;
49564 PyObject * obj3 = 0 ;
49565 PyObject * obj4 = 0 ;
49566 PyObject * obj5 = 0 ;
49567 PyObject * obj6 = 0 ;
49568 char * kwnames[] = {
49569 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49570 };
49571
49572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49573 ecode1 = SWIG_AsVal_int(obj0, &val1);
49574 if (!SWIG_IsOK(ecode1)) {
49575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49576 }
49577 arg1 = static_cast< int >(val1);
49578 ecode2 = SWIG_AsVal_int(obj1, &val2);
49579 if (!SWIG_IsOK(ecode2)) {
49580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49581 }
49582 arg2 = static_cast< int >(val2);
49583 {
49584 arg3 = &temp3;
49585 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49586 }
49587 {
49588 arg4 = &temp4;
49589 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49590 }
49591 ecode5 = SWIG_AsVal_int(obj4, &val5);
49592 if (!SWIG_IsOK(ecode5)) {
49593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49594 }
49595 arg5 = static_cast< int >(val5);
49596 ecode6 = SWIG_AsVal_int(obj5, &val6);
49597 if (!SWIG_IsOK(ecode6)) {
49598 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49599 }
49600 arg6 = static_cast< int >(val6);
49601 if (obj6) {
49602 arg7 = obj6;
49603 }
49604 {
49605 PyThreadState* __tstate = wxPyBeginAllowThreads();
49606 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49607 wxPyEndAllowThreads(__tstate);
49608 if (PyErr_Occurred()) SWIG_fail;
49609 }
49610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49611 return resultobj;
49612 fail:
49613 return NULL;
49614 }
49615
49616
49617 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49618 PyObject *resultobj = 0;
49619 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49620 wxGBPosition result;
49621 void *argp1 = 0 ;
49622 int res1 = 0 ;
49623 PyObject *swig_obj[1] ;
49624
49625 if (!args) SWIG_fail;
49626 swig_obj[0] = args;
49627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49628 if (!SWIG_IsOK(res1)) {
49629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49630 }
49631 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49632 {
49633 PyThreadState* __tstate = wxPyBeginAllowThreads();
49634 result = ((wxGBSizerItem const *)arg1)->GetPos();
49635 wxPyEndAllowThreads(__tstate);
49636 if (PyErr_Occurred()) SWIG_fail;
49637 }
49638 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49639 return resultobj;
49640 fail:
49641 return NULL;
49642 }
49643
49644
49645 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49646 PyObject *resultobj = 0;
49647 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49648 wxGBSpan result;
49649 void *argp1 = 0 ;
49650 int res1 = 0 ;
49651 PyObject *swig_obj[1] ;
49652
49653 if (!args) SWIG_fail;
49654 swig_obj[0] = args;
49655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49656 if (!SWIG_IsOK(res1)) {
49657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49658 }
49659 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49660 {
49661 PyThreadState* __tstate = wxPyBeginAllowThreads();
49662 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49663 wxPyEndAllowThreads(__tstate);
49664 if (PyErr_Occurred()) SWIG_fail;
49665 }
49666 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49667 return resultobj;
49668 fail:
49669 return NULL;
49670 }
49671
49672
49673 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49674 PyObject *resultobj = 0;
49675 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49676 wxGBPosition *arg2 = 0 ;
49677 bool result;
49678 void *argp1 = 0 ;
49679 int res1 = 0 ;
49680 wxGBPosition temp2 ;
49681 PyObject * obj0 = 0 ;
49682 PyObject * obj1 = 0 ;
49683 char * kwnames[] = {
49684 (char *) "self",(char *) "pos", NULL
49685 };
49686
49687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49689 if (!SWIG_IsOK(res1)) {
49690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49691 }
49692 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49693 {
49694 arg2 = &temp2;
49695 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49696 }
49697 {
49698 PyThreadState* __tstate = wxPyBeginAllowThreads();
49699 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49700 wxPyEndAllowThreads(__tstate);
49701 if (PyErr_Occurred()) SWIG_fail;
49702 }
49703 {
49704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49705 }
49706 return resultobj;
49707 fail:
49708 return NULL;
49709 }
49710
49711
49712 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49713 PyObject *resultobj = 0;
49714 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49715 wxGBSpan *arg2 = 0 ;
49716 bool result;
49717 void *argp1 = 0 ;
49718 int res1 = 0 ;
49719 wxGBSpan temp2 ;
49720 PyObject * obj0 = 0 ;
49721 PyObject * obj1 = 0 ;
49722 char * kwnames[] = {
49723 (char *) "self",(char *) "span", NULL
49724 };
49725
49726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49728 if (!SWIG_IsOK(res1)) {
49729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49730 }
49731 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49732 {
49733 arg2 = &temp2;
49734 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49735 }
49736 {
49737 PyThreadState* __tstate = wxPyBeginAllowThreads();
49738 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49739 wxPyEndAllowThreads(__tstate);
49740 if (PyErr_Occurred()) SWIG_fail;
49741 }
49742 {
49743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49744 }
49745 return resultobj;
49746 fail:
49747 return NULL;
49748 }
49749
49750
49751 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49752 PyObject *resultobj = 0;
49753 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49754 wxGBSizerItem *arg2 = 0 ;
49755 bool result;
49756 void *argp1 = 0 ;
49757 int res1 = 0 ;
49758 void *argp2 = 0 ;
49759 int res2 = 0 ;
49760 PyObject * obj0 = 0 ;
49761 PyObject * obj1 = 0 ;
49762 char * kwnames[] = {
49763 (char *) "self",(char *) "other", NULL
49764 };
49765
49766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49768 if (!SWIG_IsOK(res1)) {
49769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49770 }
49771 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49772 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49773 if (!SWIG_IsOK(res2)) {
49774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49775 }
49776 if (!argp2) {
49777 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49778 }
49779 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49780 {
49781 PyThreadState* __tstate = wxPyBeginAllowThreads();
49782 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49783 wxPyEndAllowThreads(__tstate);
49784 if (PyErr_Occurred()) SWIG_fail;
49785 }
49786 {
49787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49788 }
49789 return resultobj;
49790 fail:
49791 return NULL;
49792 }
49793
49794
49795 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49796 PyObject *resultobj = 0;
49797 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49798 wxGBPosition *arg2 = 0 ;
49799 wxGBSpan *arg3 = 0 ;
49800 bool result;
49801 void *argp1 = 0 ;
49802 int res1 = 0 ;
49803 wxGBPosition temp2 ;
49804 wxGBSpan temp3 ;
49805 PyObject * obj0 = 0 ;
49806 PyObject * obj1 = 0 ;
49807 PyObject * obj2 = 0 ;
49808 char * kwnames[] = {
49809 (char *) "self",(char *) "pos",(char *) "span", NULL
49810 };
49811
49812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49814 if (!SWIG_IsOK(res1)) {
49815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49816 }
49817 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49818 {
49819 arg2 = &temp2;
49820 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49821 }
49822 {
49823 arg3 = &temp3;
49824 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49825 }
49826 {
49827 PyThreadState* __tstate = wxPyBeginAllowThreads();
49828 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49829 wxPyEndAllowThreads(__tstate);
49830 if (PyErr_Occurred()) SWIG_fail;
49831 }
49832 {
49833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49834 }
49835 return resultobj;
49836 fail:
49837 return NULL;
49838 }
49839
49840
49841 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49842 PyObject *resultobj = 0;
49843 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49844 wxGBPosition result;
49845 void *argp1 = 0 ;
49846 int res1 = 0 ;
49847 PyObject *swig_obj[1] ;
49848
49849 if (!args) SWIG_fail;
49850 swig_obj[0] = args;
49851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49852 if (!SWIG_IsOK(res1)) {
49853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49854 }
49855 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49856 {
49857 PyThreadState* __tstate = wxPyBeginAllowThreads();
49858 result = wxGBSizerItem_GetEndPos(arg1);
49859 wxPyEndAllowThreads(__tstate);
49860 if (PyErr_Occurred()) SWIG_fail;
49861 }
49862 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49863 return resultobj;
49864 fail:
49865 return NULL;
49866 }
49867
49868
49869 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49870 PyObject *resultobj = 0;
49871 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49872 wxGridBagSizer *result = 0 ;
49873 void *argp1 = 0 ;
49874 int res1 = 0 ;
49875 PyObject *swig_obj[1] ;
49876
49877 if (!args) SWIG_fail;
49878 swig_obj[0] = args;
49879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49880 if (!SWIG_IsOK(res1)) {
49881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49882 }
49883 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49884 {
49885 PyThreadState* __tstate = wxPyBeginAllowThreads();
49886 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49887 wxPyEndAllowThreads(__tstate);
49888 if (PyErr_Occurred()) SWIG_fail;
49889 }
49890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49891 return resultobj;
49892 fail:
49893 return NULL;
49894 }
49895
49896
49897 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49898 PyObject *resultobj = 0;
49899 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49900 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49901 void *argp1 = 0 ;
49902 int res1 = 0 ;
49903 void *argp2 = 0 ;
49904 int res2 = 0 ;
49905 PyObject * obj0 = 0 ;
49906 PyObject * obj1 = 0 ;
49907 char * kwnames[] = {
49908 (char *) "self",(char *) "sizer", NULL
49909 };
49910
49911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49913 if (!SWIG_IsOK(res1)) {
49914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49915 }
49916 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49917 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49918 if (!SWIG_IsOK(res2)) {
49919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49920 }
49921 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49922 {
49923 PyThreadState* __tstate = wxPyBeginAllowThreads();
49924 (arg1)->SetGBSizer(arg2);
49925 wxPyEndAllowThreads(__tstate);
49926 if (PyErr_Occurred()) SWIG_fail;
49927 }
49928 resultobj = SWIG_Py_Void();
49929 return resultobj;
49930 fail:
49931 return NULL;
49932 }
49933
49934
49935 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49936 PyObject *obj;
49937 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49938 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49939 return SWIG_Py_Void();
49940 }
49941
49942 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49943 return SWIG_Python_InitShadowInstance(args);
49944 }
49945
49946 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49947 PyObject *resultobj = 0;
49948 int arg1 = (int) 0 ;
49949 int arg2 = (int) 0 ;
49950 wxGridBagSizer *result = 0 ;
49951 int val1 ;
49952 int ecode1 = 0 ;
49953 int val2 ;
49954 int ecode2 = 0 ;
49955 PyObject * obj0 = 0 ;
49956 PyObject * obj1 = 0 ;
49957 char * kwnames[] = {
49958 (char *) "vgap",(char *) "hgap", NULL
49959 };
49960
49961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49962 if (obj0) {
49963 ecode1 = SWIG_AsVal_int(obj0, &val1);
49964 if (!SWIG_IsOK(ecode1)) {
49965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49966 }
49967 arg1 = static_cast< int >(val1);
49968 }
49969 if (obj1) {
49970 ecode2 = SWIG_AsVal_int(obj1, &val2);
49971 if (!SWIG_IsOK(ecode2)) {
49972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49973 }
49974 arg2 = static_cast< int >(val2);
49975 }
49976 {
49977 PyThreadState* __tstate = wxPyBeginAllowThreads();
49978 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49979 wxPyEndAllowThreads(__tstate);
49980 if (PyErr_Occurred()) SWIG_fail;
49981 }
49982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49983 return resultobj;
49984 fail:
49985 return NULL;
49986 }
49987
49988
49989 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49990 PyObject *resultobj = 0;
49991 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49992 PyObject *arg2 = (PyObject *) 0 ;
49993 wxGBPosition *arg3 = 0 ;
49994 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49995 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49996 int arg5 = (int) 0 ;
49997 int arg6 = (int) 0 ;
49998 PyObject *arg7 = (PyObject *) NULL ;
49999 wxGBSizerItem *result = 0 ;
50000 void *argp1 = 0 ;
50001 int res1 = 0 ;
50002 wxGBPosition temp3 ;
50003 wxGBSpan temp4 ;
50004 int val5 ;
50005 int ecode5 = 0 ;
50006 int val6 ;
50007 int ecode6 = 0 ;
50008 PyObject * obj0 = 0 ;
50009 PyObject * obj1 = 0 ;
50010 PyObject * obj2 = 0 ;
50011 PyObject * obj3 = 0 ;
50012 PyObject * obj4 = 0 ;
50013 PyObject * obj5 = 0 ;
50014 PyObject * obj6 = 0 ;
50015 char * kwnames[] = {
50016 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50017 };
50018
50019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50021 if (!SWIG_IsOK(res1)) {
50022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50023 }
50024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50025 arg2 = obj1;
50026 {
50027 arg3 = &temp3;
50028 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50029 }
50030 if (obj3) {
50031 {
50032 arg4 = &temp4;
50033 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50034 }
50035 }
50036 if (obj4) {
50037 ecode5 = SWIG_AsVal_int(obj4, &val5);
50038 if (!SWIG_IsOK(ecode5)) {
50039 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50040 }
50041 arg5 = static_cast< int >(val5);
50042 }
50043 if (obj5) {
50044 ecode6 = SWIG_AsVal_int(obj5, &val6);
50045 if (!SWIG_IsOK(ecode6)) {
50046 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50047 }
50048 arg6 = static_cast< int >(val6);
50049 }
50050 if (obj6) {
50051 arg7 = obj6;
50052 }
50053 {
50054 PyThreadState* __tstate = wxPyBeginAllowThreads();
50055 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50056 wxPyEndAllowThreads(__tstate);
50057 if (PyErr_Occurred()) SWIG_fail;
50058 }
50059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50060 return resultobj;
50061 fail:
50062 return NULL;
50063 }
50064
50065
50066 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50067 PyObject *resultobj = 0;
50068 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50069 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50070 wxGBSizerItem *result = 0 ;
50071 void *argp1 = 0 ;
50072 int res1 = 0 ;
50073 int res2 = 0 ;
50074 PyObject * obj0 = 0 ;
50075 PyObject * obj1 = 0 ;
50076 char * kwnames[] = {
50077 (char *) "self",(char *) "item", NULL
50078 };
50079
50080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50082 if (!SWIG_IsOK(res1)) {
50083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50084 }
50085 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50086 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50087 if (!SWIG_IsOK(res2)) {
50088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50089 }
50090 {
50091 PyThreadState* __tstate = wxPyBeginAllowThreads();
50092 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50093 wxPyEndAllowThreads(__tstate);
50094 if (PyErr_Occurred()) SWIG_fail;
50095 }
50096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50097 return resultobj;
50098 fail:
50099 return NULL;
50100 }
50101
50102
50103 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50104 PyObject *resultobj = 0;
50105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50106 int arg2 ;
50107 int arg3 ;
50108 wxSize result;
50109 void *argp1 = 0 ;
50110 int res1 = 0 ;
50111 int val2 ;
50112 int ecode2 = 0 ;
50113 int val3 ;
50114 int ecode3 = 0 ;
50115 PyObject * obj0 = 0 ;
50116 PyObject * obj1 = 0 ;
50117 PyObject * obj2 = 0 ;
50118 char * kwnames[] = {
50119 (char *) "self",(char *) "row",(char *) "col", NULL
50120 };
50121
50122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50124 if (!SWIG_IsOK(res1)) {
50125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50126 }
50127 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50128 ecode2 = SWIG_AsVal_int(obj1, &val2);
50129 if (!SWIG_IsOK(ecode2)) {
50130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50131 }
50132 arg2 = static_cast< int >(val2);
50133 ecode3 = SWIG_AsVal_int(obj2, &val3);
50134 if (!SWIG_IsOK(ecode3)) {
50135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50136 }
50137 arg3 = static_cast< int >(val3);
50138 {
50139 PyThreadState* __tstate = wxPyBeginAllowThreads();
50140 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50141 wxPyEndAllowThreads(__tstate);
50142 if (PyErr_Occurred()) SWIG_fail;
50143 }
50144 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50152 PyObject *resultobj = 0;
50153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50154 wxSize result;
50155 void *argp1 = 0 ;
50156 int res1 = 0 ;
50157 PyObject *swig_obj[1] ;
50158
50159 if (!args) SWIG_fail;
50160 swig_obj[0] = args;
50161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50162 if (!SWIG_IsOK(res1)) {
50163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50164 }
50165 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50166 {
50167 PyThreadState* __tstate = wxPyBeginAllowThreads();
50168 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50169 wxPyEndAllowThreads(__tstate);
50170 if (PyErr_Occurred()) SWIG_fail;
50171 }
50172 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50173 return resultobj;
50174 fail:
50175 return NULL;
50176 }
50177
50178
50179 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50180 PyObject *resultobj = 0;
50181 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50182 wxSize *arg2 = 0 ;
50183 void *argp1 = 0 ;
50184 int res1 = 0 ;
50185 wxSize temp2 ;
50186 PyObject * obj0 = 0 ;
50187 PyObject * obj1 = 0 ;
50188 char * kwnames[] = {
50189 (char *) "self",(char *) "sz", NULL
50190 };
50191
50192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50194 if (!SWIG_IsOK(res1)) {
50195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50196 }
50197 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50198 {
50199 arg2 = &temp2;
50200 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50201 }
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 resultobj = SWIG_Py_Void();
50209 return resultobj;
50210 fail:
50211 return NULL;
50212 }
50213
50214
50215 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50216 PyObject *resultobj = 0;
50217 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50218 wxWindow *arg2 = (wxWindow *) 0 ;
50219 wxGBPosition result;
50220 void *argp1 = 0 ;
50221 int res1 = 0 ;
50222 void *argp2 = 0 ;
50223 int res2 = 0 ;
50224
50225 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50227 if (!SWIG_IsOK(res1)) {
50228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50229 }
50230 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50231 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50232 if (!SWIG_IsOK(res2)) {
50233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50234 }
50235 arg2 = reinterpret_cast< wxWindow * >(argp2);
50236 {
50237 PyThreadState* __tstate = wxPyBeginAllowThreads();
50238 result = (arg1)->GetItemPosition(arg2);
50239 wxPyEndAllowThreads(__tstate);
50240 if (PyErr_Occurred()) SWIG_fail;
50241 }
50242 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50243 return resultobj;
50244 fail:
50245 return NULL;
50246 }
50247
50248
50249 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50250 PyObject *resultobj = 0;
50251 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50252 wxSizer *arg2 = (wxSizer *) 0 ;
50253 wxGBPosition result;
50254 void *argp1 = 0 ;
50255 int res1 = 0 ;
50256 void *argp2 = 0 ;
50257 int res2 = 0 ;
50258
50259 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50261 if (!SWIG_IsOK(res1)) {
50262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50263 }
50264 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50265 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50266 if (!SWIG_IsOK(res2)) {
50267 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50268 }
50269 arg2 = reinterpret_cast< wxSizer * >(argp2);
50270 {
50271 PyThreadState* __tstate = wxPyBeginAllowThreads();
50272 result = (arg1)->GetItemPosition(arg2);
50273 wxPyEndAllowThreads(__tstate);
50274 if (PyErr_Occurred()) SWIG_fail;
50275 }
50276 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50277 return resultobj;
50278 fail:
50279 return NULL;
50280 }
50281
50282
50283 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50284 PyObject *resultobj = 0;
50285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50286 size_t arg2 ;
50287 wxGBPosition result;
50288 void *argp1 = 0 ;
50289 int res1 = 0 ;
50290 size_t val2 ;
50291 int ecode2 = 0 ;
50292
50293 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50295 if (!SWIG_IsOK(res1)) {
50296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50297 }
50298 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50299 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50300 if (!SWIG_IsOK(ecode2)) {
50301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50302 }
50303 arg2 = static_cast< size_t >(val2);
50304 {
50305 PyThreadState* __tstate = wxPyBeginAllowThreads();
50306 result = (arg1)->GetItemPosition(arg2);
50307 wxPyEndAllowThreads(__tstate);
50308 if (PyErr_Occurred()) SWIG_fail;
50309 }
50310 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50318 int argc;
50319 PyObject *argv[3];
50320
50321 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50322 --argc;
50323 if (argc == 2) {
50324 int _v = 0;
50325 {
50326 void *vptr = 0;
50327 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50328 _v = SWIG_CheckState(res);
50329 }
50330 if (!_v) goto check_1;
50331 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50332 }
50333 check_1:
50334
50335 if (argc == 2) {
50336 int _v = 0;
50337 {
50338 void *vptr = 0;
50339 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50340 _v = SWIG_CheckState(res);
50341 }
50342 if (!_v) goto check_2;
50343 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50344 }
50345 check_2:
50346
50347 if (argc == 2) {
50348 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50349 }
50350
50351 fail:
50352 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50353 return NULL;
50354 }
50355
50356
50357 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50358 PyObject *resultobj = 0;
50359 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50360 wxWindow *arg2 = (wxWindow *) 0 ;
50361 wxGBPosition *arg3 = 0 ;
50362 bool result;
50363 void *argp1 = 0 ;
50364 int res1 = 0 ;
50365 void *argp2 = 0 ;
50366 int res2 = 0 ;
50367 wxGBPosition temp3 ;
50368
50369 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50371 if (!SWIG_IsOK(res1)) {
50372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50373 }
50374 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50375 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50376 if (!SWIG_IsOK(res2)) {
50377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50378 }
50379 arg2 = reinterpret_cast< wxWindow * >(argp2);
50380 {
50381 arg3 = &temp3;
50382 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50383 }
50384 {
50385 PyThreadState* __tstate = wxPyBeginAllowThreads();
50386 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50387 wxPyEndAllowThreads(__tstate);
50388 if (PyErr_Occurred()) SWIG_fail;
50389 }
50390 {
50391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50392 }
50393 return resultobj;
50394 fail:
50395 return NULL;
50396 }
50397
50398
50399 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50400 PyObject *resultobj = 0;
50401 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50402 wxSizer *arg2 = (wxSizer *) 0 ;
50403 wxGBPosition *arg3 = 0 ;
50404 bool result;
50405 void *argp1 = 0 ;
50406 int res1 = 0 ;
50407 void *argp2 = 0 ;
50408 int res2 = 0 ;
50409 wxGBPosition temp3 ;
50410
50411 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50413 if (!SWIG_IsOK(res1)) {
50414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50415 }
50416 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50417 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50418 if (!SWIG_IsOK(res2)) {
50419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50420 }
50421 arg2 = reinterpret_cast< wxSizer * >(argp2);
50422 {
50423 arg3 = &temp3;
50424 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50425 }
50426 {
50427 PyThreadState* __tstate = wxPyBeginAllowThreads();
50428 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50429 wxPyEndAllowThreads(__tstate);
50430 if (PyErr_Occurred()) SWIG_fail;
50431 }
50432 {
50433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50434 }
50435 return resultobj;
50436 fail:
50437 return NULL;
50438 }
50439
50440
50441 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50442 PyObject *resultobj = 0;
50443 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50444 size_t arg2 ;
50445 wxGBPosition *arg3 = 0 ;
50446 bool result;
50447 void *argp1 = 0 ;
50448 int res1 = 0 ;
50449 size_t val2 ;
50450 int ecode2 = 0 ;
50451 wxGBPosition temp3 ;
50452
50453 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50455 if (!SWIG_IsOK(res1)) {
50456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50457 }
50458 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50459 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50460 if (!SWIG_IsOK(ecode2)) {
50461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50462 }
50463 arg2 = static_cast< size_t >(val2);
50464 {
50465 arg3 = &temp3;
50466 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50467 }
50468 {
50469 PyThreadState* __tstate = wxPyBeginAllowThreads();
50470 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50471 wxPyEndAllowThreads(__tstate);
50472 if (PyErr_Occurred()) SWIG_fail;
50473 }
50474 {
50475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50476 }
50477 return resultobj;
50478 fail:
50479 return NULL;
50480 }
50481
50482
50483 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50484 int argc;
50485 PyObject *argv[4];
50486
50487 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50488 --argc;
50489 if (argc == 3) {
50490 int _v = 0;
50491 {
50492 void *vptr = 0;
50493 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50494 _v = SWIG_CheckState(res);
50495 }
50496 if (!_v) goto check_1;
50497 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50498 }
50499 check_1:
50500
50501 if (argc == 3) {
50502 int _v = 0;
50503 {
50504 void *vptr = 0;
50505 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50506 _v = SWIG_CheckState(res);
50507 }
50508 if (!_v) goto check_2;
50509 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50510 }
50511 check_2:
50512
50513 if (argc == 3) {
50514 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50515 }
50516
50517 fail:
50518 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50519 return NULL;
50520 }
50521
50522
50523 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50524 PyObject *resultobj = 0;
50525 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50526 wxWindow *arg2 = (wxWindow *) 0 ;
50527 wxGBSpan result;
50528 void *argp1 = 0 ;
50529 int res1 = 0 ;
50530 void *argp2 = 0 ;
50531 int res2 = 0 ;
50532
50533 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50535 if (!SWIG_IsOK(res1)) {
50536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50537 }
50538 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50539 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50540 if (!SWIG_IsOK(res2)) {
50541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50542 }
50543 arg2 = reinterpret_cast< wxWindow * >(argp2);
50544 {
50545 PyThreadState* __tstate = wxPyBeginAllowThreads();
50546 result = (arg1)->GetItemSpan(arg2);
50547 wxPyEndAllowThreads(__tstate);
50548 if (PyErr_Occurred()) SWIG_fail;
50549 }
50550 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50551 return resultobj;
50552 fail:
50553 return NULL;
50554 }
50555
50556
50557 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50558 PyObject *resultobj = 0;
50559 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50560 wxSizer *arg2 = (wxSizer *) 0 ;
50561 wxGBSpan result;
50562 void *argp1 = 0 ;
50563 int res1 = 0 ;
50564 void *argp2 = 0 ;
50565 int res2 = 0 ;
50566
50567 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50569 if (!SWIG_IsOK(res1)) {
50570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50571 }
50572 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50573 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50574 if (!SWIG_IsOK(res2)) {
50575 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50576 }
50577 arg2 = reinterpret_cast< wxSizer * >(argp2);
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 result = (arg1)->GetItemSpan(arg2);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50592 PyObject *resultobj = 0;
50593 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50594 size_t arg2 ;
50595 wxGBSpan result;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 size_t val2 ;
50599 int ecode2 = 0 ;
50600
50601 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res1)) {
50604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50605 }
50606 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50607 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50608 if (!SWIG_IsOK(ecode2)) {
50609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50610 }
50611 arg2 = static_cast< size_t >(val2);
50612 {
50613 PyThreadState* __tstate = wxPyBeginAllowThreads();
50614 result = (arg1)->GetItemSpan(arg2);
50615 wxPyEndAllowThreads(__tstate);
50616 if (PyErr_Occurred()) SWIG_fail;
50617 }
50618 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50619 return resultobj;
50620 fail:
50621 return NULL;
50622 }
50623
50624
50625 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50626 int argc;
50627 PyObject *argv[3];
50628
50629 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50630 --argc;
50631 if (argc == 2) {
50632 int _v = 0;
50633 {
50634 void *vptr = 0;
50635 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50636 _v = SWIG_CheckState(res);
50637 }
50638 if (!_v) goto check_1;
50639 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50640 }
50641 check_1:
50642
50643 if (argc == 2) {
50644 int _v = 0;
50645 {
50646 void *vptr = 0;
50647 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50648 _v = SWIG_CheckState(res);
50649 }
50650 if (!_v) goto check_2;
50651 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50652 }
50653 check_2:
50654
50655 if (argc == 2) {
50656 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50657 }
50658
50659 fail:
50660 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50661 return NULL;
50662 }
50663
50664
50665 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50666 PyObject *resultobj = 0;
50667 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50668 wxWindow *arg2 = (wxWindow *) 0 ;
50669 wxGBSpan *arg3 = 0 ;
50670 bool result;
50671 void *argp1 = 0 ;
50672 int res1 = 0 ;
50673 void *argp2 = 0 ;
50674 int res2 = 0 ;
50675 wxGBSpan temp3 ;
50676
50677 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50679 if (!SWIG_IsOK(res1)) {
50680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50681 }
50682 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50683 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50684 if (!SWIG_IsOK(res2)) {
50685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50686 }
50687 arg2 = reinterpret_cast< wxWindow * >(argp2);
50688 {
50689 arg3 = &temp3;
50690 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50691 }
50692 {
50693 PyThreadState* __tstate = wxPyBeginAllowThreads();
50694 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50695 wxPyEndAllowThreads(__tstate);
50696 if (PyErr_Occurred()) SWIG_fail;
50697 }
50698 {
50699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50700 }
50701 return resultobj;
50702 fail:
50703 return NULL;
50704 }
50705
50706
50707 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50708 PyObject *resultobj = 0;
50709 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50710 wxSizer *arg2 = (wxSizer *) 0 ;
50711 wxGBSpan *arg3 = 0 ;
50712 bool result;
50713 void *argp1 = 0 ;
50714 int res1 = 0 ;
50715 void *argp2 = 0 ;
50716 int res2 = 0 ;
50717 wxGBSpan temp3 ;
50718
50719 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50721 if (!SWIG_IsOK(res1)) {
50722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50723 }
50724 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50726 if (!SWIG_IsOK(res2)) {
50727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50728 }
50729 arg2 = reinterpret_cast< wxSizer * >(argp2);
50730 {
50731 arg3 = &temp3;
50732 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50733 }
50734 {
50735 PyThreadState* __tstate = wxPyBeginAllowThreads();
50736 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50737 wxPyEndAllowThreads(__tstate);
50738 if (PyErr_Occurred()) SWIG_fail;
50739 }
50740 {
50741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50742 }
50743 return resultobj;
50744 fail:
50745 return NULL;
50746 }
50747
50748
50749 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50750 PyObject *resultobj = 0;
50751 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50752 size_t arg2 ;
50753 wxGBSpan *arg3 = 0 ;
50754 bool result;
50755 void *argp1 = 0 ;
50756 int res1 = 0 ;
50757 size_t val2 ;
50758 int ecode2 = 0 ;
50759 wxGBSpan temp3 ;
50760
50761 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50763 if (!SWIG_IsOK(res1)) {
50764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50765 }
50766 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50767 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50768 if (!SWIG_IsOK(ecode2)) {
50769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50770 }
50771 arg2 = static_cast< size_t >(val2);
50772 {
50773 arg3 = &temp3;
50774 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50775 }
50776 {
50777 PyThreadState* __tstate = wxPyBeginAllowThreads();
50778 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50779 wxPyEndAllowThreads(__tstate);
50780 if (PyErr_Occurred()) SWIG_fail;
50781 }
50782 {
50783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50784 }
50785 return resultobj;
50786 fail:
50787 return NULL;
50788 }
50789
50790
50791 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50792 int argc;
50793 PyObject *argv[4];
50794
50795 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50796 --argc;
50797 if (argc == 3) {
50798 int _v = 0;
50799 {
50800 void *vptr = 0;
50801 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50802 _v = SWIG_CheckState(res);
50803 }
50804 if (!_v) goto check_1;
50805 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50806 }
50807 check_1:
50808
50809 if (argc == 3) {
50810 int _v = 0;
50811 {
50812 void *vptr = 0;
50813 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50814 _v = SWIG_CheckState(res);
50815 }
50816 if (!_v) goto check_2;
50817 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50818 }
50819 check_2:
50820
50821 if (argc == 3) {
50822 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50823 }
50824
50825 fail:
50826 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50827 return NULL;
50828 }
50829
50830
50831 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50832 PyObject *resultobj = 0;
50833 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50834 wxWindow *arg2 = (wxWindow *) 0 ;
50835 wxGBSizerItem *result = 0 ;
50836 void *argp1 = 0 ;
50837 int res1 = 0 ;
50838 void *argp2 = 0 ;
50839 int res2 = 0 ;
50840
50841 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50843 if (!SWIG_IsOK(res1)) {
50844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50845 }
50846 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50847 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50848 if (!SWIG_IsOK(res2)) {
50849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50850 }
50851 arg2 = reinterpret_cast< wxWindow * >(argp2);
50852 {
50853 PyThreadState* __tstate = wxPyBeginAllowThreads();
50854 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50855 wxPyEndAllowThreads(__tstate);
50856 if (PyErr_Occurred()) SWIG_fail;
50857 }
50858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50859 return resultobj;
50860 fail:
50861 return NULL;
50862 }
50863
50864
50865 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50866 PyObject *resultobj = 0;
50867 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50868 wxSizer *arg2 = (wxSizer *) 0 ;
50869 wxGBSizerItem *result = 0 ;
50870 void *argp1 = 0 ;
50871 int res1 = 0 ;
50872 void *argp2 = 0 ;
50873 int res2 = 0 ;
50874
50875 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50877 if (!SWIG_IsOK(res1)) {
50878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50879 }
50880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50881 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50882 if (!SWIG_IsOK(res2)) {
50883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50884 }
50885 arg2 = reinterpret_cast< wxSizer * >(argp2);
50886 {
50887 PyThreadState* __tstate = wxPyBeginAllowThreads();
50888 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50889 wxPyEndAllowThreads(__tstate);
50890 if (PyErr_Occurred()) SWIG_fail;
50891 }
50892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50893 return resultobj;
50894 fail:
50895 return NULL;
50896 }
50897
50898
50899 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50900 int argc;
50901 PyObject *argv[3];
50902
50903 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50904 --argc;
50905 if (argc == 2) {
50906 int _v = 0;
50907 {
50908 void *vptr = 0;
50909 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50910 _v = SWIG_CheckState(res);
50911 }
50912 if (!_v) goto check_1;
50913 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50914 }
50915 check_1:
50916
50917 if (argc == 2) {
50918 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50919 }
50920
50921 fail:
50922 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50923 return NULL;
50924 }
50925
50926
50927 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50928 PyObject *resultobj = 0;
50929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50930 wxGBPosition *arg2 = 0 ;
50931 wxGBSizerItem *result = 0 ;
50932 void *argp1 = 0 ;
50933 int res1 = 0 ;
50934 wxGBPosition temp2 ;
50935 PyObject * obj0 = 0 ;
50936 PyObject * obj1 = 0 ;
50937 char * kwnames[] = {
50938 (char *) "self",(char *) "pos", NULL
50939 };
50940
50941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50943 if (!SWIG_IsOK(res1)) {
50944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50945 }
50946 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50947 {
50948 arg2 = &temp2;
50949 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50950 }
50951 {
50952 PyThreadState* __tstate = wxPyBeginAllowThreads();
50953 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50954 wxPyEndAllowThreads(__tstate);
50955 if (PyErr_Occurred()) SWIG_fail;
50956 }
50957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50958 return resultobj;
50959 fail:
50960 return NULL;
50961 }
50962
50963
50964 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50965 PyObject *resultobj = 0;
50966 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50967 wxPoint *arg2 = 0 ;
50968 wxGBSizerItem *result = 0 ;
50969 void *argp1 = 0 ;
50970 int res1 = 0 ;
50971 wxPoint temp2 ;
50972 PyObject * obj0 = 0 ;
50973 PyObject * obj1 = 0 ;
50974 char * kwnames[] = {
50975 (char *) "self",(char *) "pt", NULL
50976 };
50977
50978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50980 if (!SWIG_IsOK(res1)) {
50981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50982 }
50983 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50984 {
50985 arg2 = &temp2;
50986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50987 }
50988 {
50989 PyThreadState* __tstate = wxPyBeginAllowThreads();
50990 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50991 wxPyEndAllowThreads(__tstate);
50992 if (PyErr_Occurred()) SWIG_fail;
50993 }
50994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50995 return resultobj;
50996 fail:
50997 return NULL;
50998 }
50999
51000
51001 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51002 PyObject *resultobj = 0;
51003 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51004 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51005 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51006 bool result;
51007 void *argp1 = 0 ;
51008 int res1 = 0 ;
51009 void *argp2 = 0 ;
51010 int res2 = 0 ;
51011 void *argp3 = 0 ;
51012 int res3 = 0 ;
51013 PyObject * obj0 = 0 ;
51014 PyObject * obj1 = 0 ;
51015 PyObject * obj2 = 0 ;
51016 char * kwnames[] = {
51017 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51018 };
51019
51020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51022 if (!SWIG_IsOK(res1)) {
51023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51024 }
51025 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51027 if (!SWIG_IsOK(res2)) {
51028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51029 }
51030 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51031 if (obj2) {
51032 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51033 if (!SWIG_IsOK(res3)) {
51034 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51035 }
51036 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51037 }
51038 {
51039 PyThreadState* __tstate = wxPyBeginAllowThreads();
51040 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51041 wxPyEndAllowThreads(__tstate);
51042 if (PyErr_Occurred()) SWIG_fail;
51043 }
51044 {
51045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51046 }
51047 return resultobj;
51048 fail:
51049 return NULL;
51050 }
51051
51052
51053 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51054 PyObject *resultobj = 0;
51055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51056 wxGBPosition *arg2 = 0 ;
51057 wxGBSpan *arg3 = 0 ;
51058 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51059 bool result;
51060 void *argp1 = 0 ;
51061 int res1 = 0 ;
51062 wxGBPosition temp2 ;
51063 wxGBSpan temp3 ;
51064 void *argp4 = 0 ;
51065 int res4 = 0 ;
51066 PyObject * obj0 = 0 ;
51067 PyObject * obj1 = 0 ;
51068 PyObject * obj2 = 0 ;
51069 PyObject * obj3 = 0 ;
51070 char * kwnames[] = {
51071 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51072 };
51073
51074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51076 if (!SWIG_IsOK(res1)) {
51077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51078 }
51079 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51080 {
51081 arg2 = &temp2;
51082 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51083 }
51084 {
51085 arg3 = &temp3;
51086 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51087 }
51088 if (obj3) {
51089 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51090 if (!SWIG_IsOK(res4)) {
51091 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51092 }
51093 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51094 }
51095 {
51096 PyThreadState* __tstate = wxPyBeginAllowThreads();
51097 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51098 wxPyEndAllowThreads(__tstate);
51099 if (PyErr_Occurred()) SWIG_fail;
51100 }
51101 {
51102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51103 }
51104 return resultobj;
51105 fail:
51106 return NULL;
51107 }
51108
51109
51110 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51111 PyObject *obj;
51112 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51113 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51114 return SWIG_Py_Void();
51115 }
51116
51117 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51118 return SWIG_Python_InitShadowInstance(args);
51119 }
51120
51121 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51122 PyObject *resultobj = 0;
51123 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51124 wxRelationship arg2 ;
51125 wxWindow *arg3 = (wxWindow *) 0 ;
51126 wxEdge arg4 ;
51127 int arg5 = (int) 0 ;
51128 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 int val2 ;
51132 int ecode2 = 0 ;
51133 void *argp3 = 0 ;
51134 int res3 = 0 ;
51135 int val4 ;
51136 int ecode4 = 0 ;
51137 int val5 ;
51138 int ecode5 = 0 ;
51139 int val6 ;
51140 int ecode6 = 0 ;
51141 PyObject * obj0 = 0 ;
51142 PyObject * obj1 = 0 ;
51143 PyObject * obj2 = 0 ;
51144 PyObject * obj3 = 0 ;
51145 PyObject * obj4 = 0 ;
51146 PyObject * obj5 = 0 ;
51147 char * kwnames[] = {
51148 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51149 };
51150
51151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51153 if (!SWIG_IsOK(res1)) {
51154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51155 }
51156 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51157 ecode2 = SWIG_AsVal_int(obj1, &val2);
51158 if (!SWIG_IsOK(ecode2)) {
51159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51160 }
51161 arg2 = static_cast< wxRelationship >(val2);
51162 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51163 if (!SWIG_IsOK(res3)) {
51164 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51165 }
51166 arg3 = reinterpret_cast< wxWindow * >(argp3);
51167 ecode4 = SWIG_AsVal_int(obj3, &val4);
51168 if (!SWIG_IsOK(ecode4)) {
51169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51170 }
51171 arg4 = static_cast< wxEdge >(val4);
51172 if (obj4) {
51173 ecode5 = SWIG_AsVal_int(obj4, &val5);
51174 if (!SWIG_IsOK(ecode5)) {
51175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51176 }
51177 arg5 = static_cast< int >(val5);
51178 }
51179 if (obj5) {
51180 ecode6 = SWIG_AsVal_int(obj5, &val6);
51181 if (!SWIG_IsOK(ecode6)) {
51182 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51183 }
51184 arg6 = static_cast< int >(val6);
51185 }
51186 {
51187 PyThreadState* __tstate = wxPyBeginAllowThreads();
51188 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51189 wxPyEndAllowThreads(__tstate);
51190 if (PyErr_Occurred()) SWIG_fail;
51191 }
51192 resultobj = SWIG_Py_Void();
51193 return resultobj;
51194 fail:
51195 return NULL;
51196 }
51197
51198
51199 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51200 PyObject *resultobj = 0;
51201 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51202 wxWindow *arg2 = (wxWindow *) 0 ;
51203 int arg3 = (int) 0 ;
51204 void *argp1 = 0 ;
51205 int res1 = 0 ;
51206 void *argp2 = 0 ;
51207 int res2 = 0 ;
51208 int val3 ;
51209 int ecode3 = 0 ;
51210 PyObject * obj0 = 0 ;
51211 PyObject * obj1 = 0 ;
51212 PyObject * obj2 = 0 ;
51213 char * kwnames[] = {
51214 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51215 };
51216
51217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51219 if (!SWIG_IsOK(res1)) {
51220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51221 }
51222 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51224 if (!SWIG_IsOK(res2)) {
51225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51226 }
51227 arg2 = reinterpret_cast< wxWindow * >(argp2);
51228 if (obj2) {
51229 ecode3 = SWIG_AsVal_int(obj2, &val3);
51230 if (!SWIG_IsOK(ecode3)) {
51231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51232 }
51233 arg3 = static_cast< int >(val3);
51234 }
51235 {
51236 PyThreadState* __tstate = wxPyBeginAllowThreads();
51237 (arg1)->LeftOf(arg2,arg3);
51238 wxPyEndAllowThreads(__tstate);
51239 if (PyErr_Occurred()) SWIG_fail;
51240 }
51241 resultobj = SWIG_Py_Void();
51242 return resultobj;
51243 fail:
51244 return NULL;
51245 }
51246
51247
51248 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51249 PyObject *resultobj = 0;
51250 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51251 wxWindow *arg2 = (wxWindow *) 0 ;
51252 int arg3 = (int) 0 ;
51253 void *argp1 = 0 ;
51254 int res1 = 0 ;
51255 void *argp2 = 0 ;
51256 int res2 = 0 ;
51257 int val3 ;
51258 int ecode3 = 0 ;
51259 PyObject * obj0 = 0 ;
51260 PyObject * obj1 = 0 ;
51261 PyObject * obj2 = 0 ;
51262 char * kwnames[] = {
51263 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51264 };
51265
51266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51268 if (!SWIG_IsOK(res1)) {
51269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51270 }
51271 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51273 if (!SWIG_IsOK(res2)) {
51274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51275 }
51276 arg2 = reinterpret_cast< wxWindow * >(argp2);
51277 if (obj2) {
51278 ecode3 = SWIG_AsVal_int(obj2, &val3);
51279 if (!SWIG_IsOK(ecode3)) {
51280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51281 }
51282 arg3 = static_cast< int >(val3);
51283 }
51284 {
51285 PyThreadState* __tstate = wxPyBeginAllowThreads();
51286 (arg1)->RightOf(arg2,arg3);
51287 wxPyEndAllowThreads(__tstate);
51288 if (PyErr_Occurred()) SWIG_fail;
51289 }
51290 resultobj = SWIG_Py_Void();
51291 return resultobj;
51292 fail:
51293 return NULL;
51294 }
51295
51296
51297 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51298 PyObject *resultobj = 0;
51299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51300 wxWindow *arg2 = (wxWindow *) 0 ;
51301 int arg3 = (int) 0 ;
51302 void *argp1 = 0 ;
51303 int res1 = 0 ;
51304 void *argp2 = 0 ;
51305 int res2 = 0 ;
51306 int val3 ;
51307 int ecode3 = 0 ;
51308 PyObject * obj0 = 0 ;
51309 PyObject * obj1 = 0 ;
51310 PyObject * obj2 = 0 ;
51311 char * kwnames[] = {
51312 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51313 };
51314
51315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51317 if (!SWIG_IsOK(res1)) {
51318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51319 }
51320 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51322 if (!SWIG_IsOK(res2)) {
51323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51324 }
51325 arg2 = reinterpret_cast< wxWindow * >(argp2);
51326 if (obj2) {
51327 ecode3 = SWIG_AsVal_int(obj2, &val3);
51328 if (!SWIG_IsOK(ecode3)) {
51329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51330 }
51331 arg3 = static_cast< int >(val3);
51332 }
51333 {
51334 PyThreadState* __tstate = wxPyBeginAllowThreads();
51335 (arg1)->Above(arg2,arg3);
51336 wxPyEndAllowThreads(__tstate);
51337 if (PyErr_Occurred()) SWIG_fail;
51338 }
51339 resultobj = SWIG_Py_Void();
51340 return resultobj;
51341 fail:
51342 return NULL;
51343 }
51344
51345
51346 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51347 PyObject *resultobj = 0;
51348 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51349 wxWindow *arg2 = (wxWindow *) 0 ;
51350 int arg3 = (int) 0 ;
51351 void *argp1 = 0 ;
51352 int res1 = 0 ;
51353 void *argp2 = 0 ;
51354 int res2 = 0 ;
51355 int val3 ;
51356 int ecode3 = 0 ;
51357 PyObject * obj0 = 0 ;
51358 PyObject * obj1 = 0 ;
51359 PyObject * obj2 = 0 ;
51360 char * kwnames[] = {
51361 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51362 };
51363
51364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51366 if (!SWIG_IsOK(res1)) {
51367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51368 }
51369 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51371 if (!SWIG_IsOK(res2)) {
51372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51373 }
51374 arg2 = reinterpret_cast< wxWindow * >(argp2);
51375 if (obj2) {
51376 ecode3 = SWIG_AsVal_int(obj2, &val3);
51377 if (!SWIG_IsOK(ecode3)) {
51378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51379 }
51380 arg3 = static_cast< int >(val3);
51381 }
51382 {
51383 PyThreadState* __tstate = wxPyBeginAllowThreads();
51384 (arg1)->Below(arg2,arg3);
51385 wxPyEndAllowThreads(__tstate);
51386 if (PyErr_Occurred()) SWIG_fail;
51387 }
51388 resultobj = SWIG_Py_Void();
51389 return resultobj;
51390 fail:
51391 return NULL;
51392 }
51393
51394
51395 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51396 PyObject *resultobj = 0;
51397 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51398 wxWindow *arg2 = (wxWindow *) 0 ;
51399 wxEdge arg3 ;
51400 int arg4 = (int) 0 ;
51401 void *argp1 = 0 ;
51402 int res1 = 0 ;
51403 void *argp2 = 0 ;
51404 int res2 = 0 ;
51405 int val3 ;
51406 int ecode3 = 0 ;
51407 int val4 ;
51408 int ecode4 = 0 ;
51409 PyObject * obj0 = 0 ;
51410 PyObject * obj1 = 0 ;
51411 PyObject * obj2 = 0 ;
51412 PyObject * obj3 = 0 ;
51413 char * kwnames[] = {
51414 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51415 };
51416
51417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51419 if (!SWIG_IsOK(res1)) {
51420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51421 }
51422 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51424 if (!SWIG_IsOK(res2)) {
51425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51426 }
51427 arg2 = reinterpret_cast< wxWindow * >(argp2);
51428 ecode3 = SWIG_AsVal_int(obj2, &val3);
51429 if (!SWIG_IsOK(ecode3)) {
51430 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51431 }
51432 arg3 = static_cast< wxEdge >(val3);
51433 if (obj3) {
51434 ecode4 = SWIG_AsVal_int(obj3, &val4);
51435 if (!SWIG_IsOK(ecode4)) {
51436 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51437 }
51438 arg4 = static_cast< int >(val4);
51439 }
51440 {
51441 PyThreadState* __tstate = wxPyBeginAllowThreads();
51442 (arg1)->SameAs(arg2,arg3,arg4);
51443 wxPyEndAllowThreads(__tstate);
51444 if (PyErr_Occurred()) SWIG_fail;
51445 }
51446 resultobj = SWIG_Py_Void();
51447 return resultobj;
51448 fail:
51449 return NULL;
51450 }
51451
51452
51453 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51454 PyObject *resultobj = 0;
51455 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51456 wxWindow *arg2 = (wxWindow *) 0 ;
51457 wxEdge arg3 ;
51458 int arg4 ;
51459 void *argp1 = 0 ;
51460 int res1 = 0 ;
51461 void *argp2 = 0 ;
51462 int res2 = 0 ;
51463 int val3 ;
51464 int ecode3 = 0 ;
51465 int val4 ;
51466 int ecode4 = 0 ;
51467 PyObject * obj0 = 0 ;
51468 PyObject * obj1 = 0 ;
51469 PyObject * obj2 = 0 ;
51470 PyObject * obj3 = 0 ;
51471 char * kwnames[] = {
51472 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51473 };
51474
51475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51477 if (!SWIG_IsOK(res1)) {
51478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51479 }
51480 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51482 if (!SWIG_IsOK(res2)) {
51483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51484 }
51485 arg2 = reinterpret_cast< wxWindow * >(argp2);
51486 ecode3 = SWIG_AsVal_int(obj2, &val3);
51487 if (!SWIG_IsOK(ecode3)) {
51488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51489 }
51490 arg3 = static_cast< wxEdge >(val3);
51491 ecode4 = SWIG_AsVal_int(obj3, &val4);
51492 if (!SWIG_IsOK(ecode4)) {
51493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51494 }
51495 arg4 = static_cast< int >(val4);
51496 {
51497 PyThreadState* __tstate = wxPyBeginAllowThreads();
51498 (arg1)->PercentOf(arg2,arg3,arg4);
51499 wxPyEndAllowThreads(__tstate);
51500 if (PyErr_Occurred()) SWIG_fail;
51501 }
51502 resultobj = SWIG_Py_Void();
51503 return resultobj;
51504 fail:
51505 return NULL;
51506 }
51507
51508
51509 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51510 PyObject *resultobj = 0;
51511 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51512 int arg2 ;
51513 void *argp1 = 0 ;
51514 int res1 = 0 ;
51515 int val2 ;
51516 int ecode2 = 0 ;
51517 PyObject * obj0 = 0 ;
51518 PyObject * obj1 = 0 ;
51519 char * kwnames[] = {
51520 (char *) "self",(char *) "val", NULL
51521 };
51522
51523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51525 if (!SWIG_IsOK(res1)) {
51526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51527 }
51528 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51529 ecode2 = SWIG_AsVal_int(obj1, &val2);
51530 if (!SWIG_IsOK(ecode2)) {
51531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51532 }
51533 arg2 = static_cast< int >(val2);
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 (arg1)->Absolute(arg2);
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_Py_Void();
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51548 PyObject *resultobj = 0;
51549 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 PyObject *swig_obj[1] ;
51553
51554 if (!args) SWIG_fail;
51555 swig_obj[0] = args;
51556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51557 if (!SWIG_IsOK(res1)) {
51558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51559 }
51560 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 (arg1)->Unconstrained();
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 resultobj = SWIG_Py_Void();
51568 return resultobj;
51569 fail:
51570 return NULL;
51571 }
51572
51573
51574 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51575 PyObject *resultobj = 0;
51576 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51577 void *argp1 = 0 ;
51578 int res1 = 0 ;
51579 PyObject *swig_obj[1] ;
51580
51581 if (!args) SWIG_fail;
51582 swig_obj[0] = args;
51583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51584 if (!SWIG_IsOK(res1)) {
51585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51586 }
51587 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51588 {
51589 PyThreadState* __tstate = wxPyBeginAllowThreads();
51590 (arg1)->AsIs();
51591 wxPyEndAllowThreads(__tstate);
51592 if (PyErr_Occurred()) SWIG_fail;
51593 }
51594 resultobj = SWIG_Py_Void();
51595 return resultobj;
51596 fail:
51597 return NULL;
51598 }
51599
51600
51601 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51602 PyObject *resultobj = 0;
51603 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51604 wxWindow *result = 0 ;
51605 void *argp1 = 0 ;
51606 int res1 = 0 ;
51607 PyObject *swig_obj[1] ;
51608
51609 if (!args) SWIG_fail;
51610 swig_obj[0] = args;
51611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51612 if (!SWIG_IsOK(res1)) {
51613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51614 }
51615 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51616 {
51617 PyThreadState* __tstate = wxPyBeginAllowThreads();
51618 result = (wxWindow *)(arg1)->GetOtherWindow();
51619 wxPyEndAllowThreads(__tstate);
51620 if (PyErr_Occurred()) SWIG_fail;
51621 }
51622 {
51623 resultobj = wxPyMake_wxObject(result, 0);
51624 }
51625 return resultobj;
51626 fail:
51627 return NULL;
51628 }
51629
51630
51631 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51632 PyObject *resultobj = 0;
51633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51634 wxEdge result;
51635 void *argp1 = 0 ;
51636 int res1 = 0 ;
51637 PyObject *swig_obj[1] ;
51638
51639 if (!args) SWIG_fail;
51640 swig_obj[0] = args;
51641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51644 }
51645 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51646 {
51647 PyThreadState* __tstate = wxPyBeginAllowThreads();
51648 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51649 wxPyEndAllowThreads(__tstate);
51650 if (PyErr_Occurred()) SWIG_fail;
51651 }
51652 resultobj = SWIG_From_int(static_cast< int >(result));
51653 return resultobj;
51654 fail:
51655 return NULL;
51656 }
51657
51658
51659 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51660 PyObject *resultobj = 0;
51661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51662 wxEdge arg2 ;
51663 void *argp1 = 0 ;
51664 int res1 = 0 ;
51665 int val2 ;
51666 int ecode2 = 0 ;
51667 PyObject * obj0 = 0 ;
51668 PyObject * obj1 = 0 ;
51669 char * kwnames[] = {
51670 (char *) "self",(char *) "which", NULL
51671 };
51672
51673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51677 }
51678 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51679 ecode2 = SWIG_AsVal_int(obj1, &val2);
51680 if (!SWIG_IsOK(ecode2)) {
51681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51682 }
51683 arg2 = static_cast< wxEdge >(val2);
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 (arg1)->SetEdge(arg2);
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 resultobj = SWIG_Py_Void();
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51698 PyObject *resultobj = 0;
51699 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51700 int arg2 ;
51701 void *argp1 = 0 ;
51702 int res1 = 0 ;
51703 int val2 ;
51704 int ecode2 = 0 ;
51705 PyObject * obj0 = 0 ;
51706 PyObject * obj1 = 0 ;
51707 char * kwnames[] = {
51708 (char *) "self",(char *) "v", NULL
51709 };
51710
51711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51713 if (!SWIG_IsOK(res1)) {
51714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51715 }
51716 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51717 ecode2 = SWIG_AsVal_int(obj1, &val2);
51718 if (!SWIG_IsOK(ecode2)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51720 }
51721 arg2 = static_cast< int >(val2);
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 (arg1)->SetValue(arg2);
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_Py_Void();
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51736 PyObject *resultobj = 0;
51737 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51738 int result;
51739 void *argp1 = 0 ;
51740 int res1 = 0 ;
51741 PyObject *swig_obj[1] ;
51742
51743 if (!args) SWIG_fail;
51744 swig_obj[0] = args;
51745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51746 if (!SWIG_IsOK(res1)) {
51747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51748 }
51749 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51750 {
51751 PyThreadState* __tstate = wxPyBeginAllowThreads();
51752 result = (int)(arg1)->GetMargin();
51753 wxPyEndAllowThreads(__tstate);
51754 if (PyErr_Occurred()) SWIG_fail;
51755 }
51756 resultobj = SWIG_From_int(static_cast< int >(result));
51757 return resultobj;
51758 fail:
51759 return NULL;
51760 }
51761
51762
51763 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51764 PyObject *resultobj = 0;
51765 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51766 int arg2 ;
51767 void *argp1 = 0 ;
51768 int res1 = 0 ;
51769 int val2 ;
51770 int ecode2 = 0 ;
51771 PyObject * obj0 = 0 ;
51772 PyObject * obj1 = 0 ;
51773 char * kwnames[] = {
51774 (char *) "self",(char *) "m", NULL
51775 };
51776
51777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51779 if (!SWIG_IsOK(res1)) {
51780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51781 }
51782 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51783 ecode2 = SWIG_AsVal_int(obj1, &val2);
51784 if (!SWIG_IsOK(ecode2)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51786 }
51787 arg2 = static_cast< int >(val2);
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 (arg1)->SetMargin(arg2);
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_Py_Void();
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51802 PyObject *resultobj = 0;
51803 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51804 int result;
51805 void *argp1 = 0 ;
51806 int res1 = 0 ;
51807 PyObject *swig_obj[1] ;
51808
51809 if (!args) SWIG_fail;
51810 swig_obj[0] = args;
51811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51814 }
51815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51816 {
51817 PyThreadState* __tstate = wxPyBeginAllowThreads();
51818 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51819 wxPyEndAllowThreads(__tstate);
51820 if (PyErr_Occurred()) SWIG_fail;
51821 }
51822 resultobj = SWIG_From_int(static_cast< int >(result));
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51830 PyObject *resultobj = 0;
51831 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51832 int result;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 PyObject *swig_obj[1] ;
51836
51837 if (!args) SWIG_fail;
51838 swig_obj[0] = args;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51842 }
51843 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51844 {
51845 PyThreadState* __tstate = wxPyBeginAllowThreads();
51846 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51847 wxPyEndAllowThreads(__tstate);
51848 if (PyErr_Occurred()) SWIG_fail;
51849 }
51850 resultobj = SWIG_From_int(static_cast< int >(result));
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51858 PyObject *resultobj = 0;
51859 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51860 int result;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 PyObject *swig_obj[1] ;
51864
51865 if (!args) SWIG_fail;
51866 swig_obj[0] = args;
51867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51868 if (!SWIG_IsOK(res1)) {
51869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51870 }
51871 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51872 {
51873 PyThreadState* __tstate = wxPyBeginAllowThreads();
51874 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51875 wxPyEndAllowThreads(__tstate);
51876 if (PyErr_Occurred()) SWIG_fail;
51877 }
51878 resultobj = SWIG_From_int(static_cast< int >(result));
51879 return resultobj;
51880 fail:
51881 return NULL;
51882 }
51883
51884
51885 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51886 PyObject *resultobj = 0;
51887 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51888 bool result;
51889 void *argp1 = 0 ;
51890 int res1 = 0 ;
51891 PyObject *swig_obj[1] ;
51892
51893 if (!args) SWIG_fail;
51894 swig_obj[0] = args;
51895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51896 if (!SWIG_IsOK(res1)) {
51897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51898 }
51899 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51900 {
51901 PyThreadState* __tstate = wxPyBeginAllowThreads();
51902 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51903 wxPyEndAllowThreads(__tstate);
51904 if (PyErr_Occurred()) SWIG_fail;
51905 }
51906 {
51907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51908 }
51909 return resultobj;
51910 fail:
51911 return NULL;
51912 }
51913
51914
51915 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51918 bool arg2 ;
51919 void *argp1 = 0 ;
51920 int res1 = 0 ;
51921 bool val2 ;
51922 int ecode2 = 0 ;
51923 PyObject * obj0 = 0 ;
51924 PyObject * obj1 = 0 ;
51925 char * kwnames[] = {
51926 (char *) "self",(char *) "d", NULL
51927 };
51928
51929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51931 if (!SWIG_IsOK(res1)) {
51932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51933 }
51934 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51935 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51936 if (!SWIG_IsOK(ecode2)) {
51937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51938 }
51939 arg2 = static_cast< bool >(val2);
51940 {
51941 PyThreadState* __tstate = wxPyBeginAllowThreads();
51942 (arg1)->SetDone(arg2);
51943 wxPyEndAllowThreads(__tstate);
51944 if (PyErr_Occurred()) SWIG_fail;
51945 }
51946 resultobj = SWIG_Py_Void();
51947 return resultobj;
51948 fail:
51949 return NULL;
51950 }
51951
51952
51953 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51954 PyObject *resultobj = 0;
51955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51956 wxRelationship result;
51957 void *argp1 = 0 ;
51958 int res1 = 0 ;
51959 PyObject *swig_obj[1] ;
51960
51961 if (!args) SWIG_fail;
51962 swig_obj[0] = args;
51963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51964 if (!SWIG_IsOK(res1)) {
51965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51966 }
51967 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51968 {
51969 PyThreadState* __tstate = wxPyBeginAllowThreads();
51970 result = (wxRelationship)(arg1)->GetRelationship();
51971 wxPyEndAllowThreads(__tstate);
51972 if (PyErr_Occurred()) SWIG_fail;
51973 }
51974 resultobj = SWIG_From_int(static_cast< int >(result));
51975 return resultobj;
51976 fail:
51977 return NULL;
51978 }
51979
51980
51981 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51982 PyObject *resultobj = 0;
51983 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51984 wxRelationship arg2 ;
51985 void *argp1 = 0 ;
51986 int res1 = 0 ;
51987 int val2 ;
51988 int ecode2 = 0 ;
51989 PyObject * obj0 = 0 ;
51990 PyObject * obj1 = 0 ;
51991 char * kwnames[] = {
51992 (char *) "self",(char *) "r", NULL
51993 };
51994
51995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51997 if (!SWIG_IsOK(res1)) {
51998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51999 }
52000 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52001 ecode2 = SWIG_AsVal_int(obj1, &val2);
52002 if (!SWIG_IsOK(ecode2)) {
52003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52004 }
52005 arg2 = static_cast< wxRelationship >(val2);
52006 {
52007 PyThreadState* __tstate = wxPyBeginAllowThreads();
52008 (arg1)->SetRelationship(arg2);
52009 wxPyEndAllowThreads(__tstate);
52010 if (PyErr_Occurred()) SWIG_fail;
52011 }
52012 resultobj = SWIG_Py_Void();
52013 return resultobj;
52014 fail:
52015 return NULL;
52016 }
52017
52018
52019 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52020 PyObject *resultobj = 0;
52021 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52022 wxWindow *arg2 = (wxWindow *) 0 ;
52023 bool result;
52024 void *argp1 = 0 ;
52025 int res1 = 0 ;
52026 void *argp2 = 0 ;
52027 int res2 = 0 ;
52028 PyObject * obj0 = 0 ;
52029 PyObject * obj1 = 0 ;
52030 char * kwnames[] = {
52031 (char *) "self",(char *) "otherW", NULL
52032 };
52033
52034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52036 if (!SWIG_IsOK(res1)) {
52037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52038 }
52039 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52040 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52041 if (!SWIG_IsOK(res2)) {
52042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52043 }
52044 arg2 = reinterpret_cast< wxWindow * >(argp2);
52045 {
52046 PyThreadState* __tstate = wxPyBeginAllowThreads();
52047 result = (bool)(arg1)->ResetIfWin(arg2);
52048 wxPyEndAllowThreads(__tstate);
52049 if (PyErr_Occurred()) SWIG_fail;
52050 }
52051 {
52052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52053 }
52054 return resultobj;
52055 fail:
52056 return NULL;
52057 }
52058
52059
52060 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52061 PyObject *resultobj = 0;
52062 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52063 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52064 wxWindow *arg3 = (wxWindow *) 0 ;
52065 bool result;
52066 void *argp1 = 0 ;
52067 int res1 = 0 ;
52068 void *argp2 = 0 ;
52069 int res2 = 0 ;
52070 void *argp3 = 0 ;
52071 int res3 = 0 ;
52072 PyObject * obj0 = 0 ;
52073 PyObject * obj1 = 0 ;
52074 PyObject * obj2 = 0 ;
52075 char * kwnames[] = {
52076 (char *) "self",(char *) "constraints",(char *) "win", NULL
52077 };
52078
52079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52081 if (!SWIG_IsOK(res1)) {
52082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52083 }
52084 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52086 if (!SWIG_IsOK(res2)) {
52087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52088 }
52089 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52090 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52091 if (!SWIG_IsOK(res3)) {
52092 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52093 }
52094 arg3 = reinterpret_cast< wxWindow * >(argp3);
52095 {
52096 PyThreadState* __tstate = wxPyBeginAllowThreads();
52097 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52098 wxPyEndAllowThreads(__tstate);
52099 if (PyErr_Occurred()) SWIG_fail;
52100 }
52101 {
52102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52103 }
52104 return resultobj;
52105 fail:
52106 return NULL;
52107 }
52108
52109
52110 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52111 PyObject *resultobj = 0;
52112 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52113 wxEdge arg2 ;
52114 wxWindow *arg3 = (wxWindow *) 0 ;
52115 wxWindow *arg4 = (wxWindow *) 0 ;
52116 int result;
52117 void *argp1 = 0 ;
52118 int res1 = 0 ;
52119 int val2 ;
52120 int ecode2 = 0 ;
52121 void *argp3 = 0 ;
52122 int res3 = 0 ;
52123 void *argp4 = 0 ;
52124 int res4 = 0 ;
52125 PyObject * obj0 = 0 ;
52126 PyObject * obj1 = 0 ;
52127 PyObject * obj2 = 0 ;
52128 PyObject * obj3 = 0 ;
52129 char * kwnames[] = {
52130 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52131 };
52132
52133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52135 if (!SWIG_IsOK(res1)) {
52136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52137 }
52138 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52139 ecode2 = SWIG_AsVal_int(obj1, &val2);
52140 if (!SWIG_IsOK(ecode2)) {
52141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52142 }
52143 arg2 = static_cast< wxEdge >(val2);
52144 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52145 if (!SWIG_IsOK(res3)) {
52146 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52147 }
52148 arg3 = reinterpret_cast< wxWindow * >(argp3);
52149 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52150 if (!SWIG_IsOK(res4)) {
52151 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52152 }
52153 arg4 = reinterpret_cast< wxWindow * >(argp4);
52154 {
52155 PyThreadState* __tstate = wxPyBeginAllowThreads();
52156 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52157 wxPyEndAllowThreads(__tstate);
52158 if (PyErr_Occurred()) SWIG_fail;
52159 }
52160 resultobj = SWIG_From_int(static_cast< int >(result));
52161 return resultobj;
52162 fail:
52163 return NULL;
52164 }
52165
52166
52167 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52168 PyObject *obj;
52169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52170 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52171 return SWIG_Py_Void();
52172 }
52173
52174 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *resultobj = 0;
52176 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52177 wxIndividualLayoutConstraint *result = 0 ;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 PyObject *swig_obj[1] ;
52181
52182 if (!args) SWIG_fail;
52183 swig_obj[0] = args;
52184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52185 if (!SWIG_IsOK(res1)) {
52186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52187 }
52188 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52189 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52191 return resultobj;
52192 fail:
52193 return NULL;
52194 }
52195
52196
52197 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52198 PyObject *resultobj = 0;
52199 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52200 wxIndividualLayoutConstraint *result = 0 ;
52201 void *argp1 = 0 ;
52202 int res1 = 0 ;
52203 PyObject *swig_obj[1] ;
52204
52205 if (!args) SWIG_fail;
52206 swig_obj[0] = args;
52207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52208 if (!SWIG_IsOK(res1)) {
52209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52210 }
52211 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52212 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52214 return resultobj;
52215 fail:
52216 return NULL;
52217 }
52218
52219
52220 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52221 PyObject *resultobj = 0;
52222 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52223 wxIndividualLayoutConstraint *result = 0 ;
52224 void *argp1 = 0 ;
52225 int res1 = 0 ;
52226 PyObject *swig_obj[1] ;
52227
52228 if (!args) SWIG_fail;
52229 swig_obj[0] = args;
52230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52231 if (!SWIG_IsOK(res1)) {
52232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52233 }
52234 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52235 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52237 return resultobj;
52238 fail:
52239 return NULL;
52240 }
52241
52242
52243 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52244 PyObject *resultobj = 0;
52245 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52246 wxIndividualLayoutConstraint *result = 0 ;
52247 void *argp1 = 0 ;
52248 int res1 = 0 ;
52249 PyObject *swig_obj[1] ;
52250
52251 if (!args) SWIG_fail;
52252 swig_obj[0] = args;
52253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52256 }
52257 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52258 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52260 return resultobj;
52261 fail:
52262 return NULL;
52263 }
52264
52265
52266 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52267 PyObject *resultobj = 0;
52268 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52269 wxIndividualLayoutConstraint *result = 0 ;
52270 void *argp1 = 0 ;
52271 int res1 = 0 ;
52272 PyObject *swig_obj[1] ;
52273
52274 if (!args) SWIG_fail;
52275 swig_obj[0] = args;
52276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52277 if (!SWIG_IsOK(res1)) {
52278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52279 }
52280 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52281 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52283 return resultobj;
52284 fail:
52285 return NULL;
52286 }
52287
52288
52289 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52290 PyObject *resultobj = 0;
52291 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52292 wxIndividualLayoutConstraint *result = 0 ;
52293 void *argp1 = 0 ;
52294 int res1 = 0 ;
52295 PyObject *swig_obj[1] ;
52296
52297 if (!args) SWIG_fail;
52298 swig_obj[0] = args;
52299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52302 }
52303 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52304 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52313 PyObject *resultobj = 0;
52314 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52315 wxIndividualLayoutConstraint *result = 0 ;
52316 void *argp1 = 0 ;
52317 int res1 = 0 ;
52318 PyObject *swig_obj[1] ;
52319
52320 if (!args) SWIG_fail;
52321 swig_obj[0] = args;
52322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52323 if (!SWIG_IsOK(res1)) {
52324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52325 }
52326 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52327 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52329 return resultobj;
52330 fail:
52331 return NULL;
52332 }
52333
52334
52335 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52336 PyObject *resultobj = 0;
52337 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52338 wxIndividualLayoutConstraint *result = 0 ;
52339 void *argp1 = 0 ;
52340 int res1 = 0 ;
52341 PyObject *swig_obj[1] ;
52342
52343 if (!args) SWIG_fail;
52344 swig_obj[0] = args;
52345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52346 if (!SWIG_IsOK(res1)) {
52347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52348 }
52349 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52350 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52352 return resultobj;
52353 fail:
52354 return NULL;
52355 }
52356
52357
52358 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52359 PyObject *resultobj = 0;
52360 wxLayoutConstraints *result = 0 ;
52361
52362 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52366 wxPyEndAllowThreads(__tstate);
52367 if (PyErr_Occurred()) SWIG_fail;
52368 }
52369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52370 return resultobj;
52371 fail:
52372 return NULL;
52373 }
52374
52375
52376 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52377 PyObject *resultobj = 0;
52378 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52379 void *argp1 = 0 ;
52380 int res1 = 0 ;
52381 PyObject *swig_obj[1] ;
52382
52383 if (!args) SWIG_fail;
52384 swig_obj[0] = args;
52385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52386 if (!SWIG_IsOK(res1)) {
52387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52388 }
52389 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52390 {
52391 PyThreadState* __tstate = wxPyBeginAllowThreads();
52392 delete arg1;
52393
52394 wxPyEndAllowThreads(__tstate);
52395 if (PyErr_Occurred()) SWIG_fail;
52396 }
52397 resultobj = SWIG_Py_Void();
52398 return resultobj;
52399 fail:
52400 return NULL;
52401 }
52402
52403
52404 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52405 PyObject *resultobj = 0;
52406 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52407 wxWindow *arg2 = (wxWindow *) 0 ;
52408 int *arg3 = (int *) 0 ;
52409 bool result;
52410 void *argp1 = 0 ;
52411 int res1 = 0 ;
52412 void *argp2 = 0 ;
52413 int res2 = 0 ;
52414 int temp3 ;
52415 int res3 = SWIG_TMPOBJ ;
52416 PyObject * obj0 = 0 ;
52417 PyObject * obj1 = 0 ;
52418 char * kwnames[] = {
52419 (char *) "self",(char *) "win", NULL
52420 };
52421
52422 arg3 = &temp3;
52423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52425 if (!SWIG_IsOK(res1)) {
52426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52427 }
52428 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52429 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52430 if (!SWIG_IsOK(res2)) {
52431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52432 }
52433 arg2 = reinterpret_cast< wxWindow * >(argp2);
52434 {
52435 PyThreadState* __tstate = wxPyBeginAllowThreads();
52436 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52437 wxPyEndAllowThreads(__tstate);
52438 if (PyErr_Occurred()) SWIG_fail;
52439 }
52440 {
52441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52442 }
52443 if (SWIG_IsTmpObj(res3)) {
52444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52445 } else {
52446 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52448 }
52449 return resultobj;
52450 fail:
52451 return NULL;
52452 }
52453
52454
52455 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52456 PyObject *resultobj = 0;
52457 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52458 bool result;
52459 void *argp1 = 0 ;
52460 int res1 = 0 ;
52461 PyObject *swig_obj[1] ;
52462
52463 if (!args) SWIG_fail;
52464 swig_obj[0] = args;
52465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52466 if (!SWIG_IsOK(res1)) {
52467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52468 }
52469 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52470 {
52471 PyThreadState* __tstate = wxPyBeginAllowThreads();
52472 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52473 wxPyEndAllowThreads(__tstate);
52474 if (PyErr_Occurred()) SWIG_fail;
52475 }
52476 {
52477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52478 }
52479 return resultobj;
52480 fail:
52481 return NULL;
52482 }
52483
52484
52485 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52486 PyObject *obj;
52487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52488 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52489 return SWIG_Py_Void();
52490 }
52491
52492 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52493 return SWIG_Python_InitShadowInstance(args);
52494 }
52495
52496 static PyMethodDef SwigMethods[] = {
52497 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52498 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52499 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52500 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52501 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52502 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52503 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52504 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52505 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52506 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52507 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52513 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52514 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52517 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52518 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52519 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52521 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52522 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52523 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52524 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52525 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52526 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52527 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52529 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52535 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52536 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52537 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52538 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52539 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52540 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52541 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52543 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52547 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52549 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52551 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52552 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52553 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52554 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52558 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52559 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52561 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52563 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52565 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52567 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52569 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52571 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52572 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52574 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52576 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52577 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52578 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52579 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52590 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52592 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52598 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52599 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52600 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52601 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52602 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52603 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52604 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52605 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52606 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52607 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52608 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52609 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52614 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52615 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52616 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52617 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52624 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52631 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52632 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52633 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52634 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52636 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52637 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52638 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52640 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52641 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52642 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52643 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52648 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52649 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52650 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52651 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52652 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52653 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52656 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52657 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52658 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52660 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52661 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52663 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52664 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52665 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52666 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52667 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52668 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52669 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52670 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52671 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52672 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52673 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52678 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52684 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52685 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52686 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52687 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52689 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52692 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52694 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52697 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52698 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52699 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52701 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52702 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52703 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52704 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52708 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52709 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52710 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52714 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52719 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52720 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52721 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52722 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52723 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52724 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52725 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52731 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52732 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52734 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52735 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52736 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52737 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52738 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52742 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52743 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52745 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52746 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52747 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52748 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52749 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52750 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52751 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52752 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52753 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52754 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52755 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52756 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52757 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52758 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52759 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52760 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52761 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52763 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52765 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52766 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52767 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52770 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52772 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52778 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52784 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52785 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52799 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52800 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52801 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52802 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52803 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52806 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52808 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52810 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52812 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52814 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52817 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52818 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52819 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52820 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52822 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52823 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52826 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52829 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52839 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52840 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52846 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52847 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52848 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52849 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52850 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52851 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52852 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52853 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52854 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52855 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52856 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52857 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52858 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52859 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52860 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52861 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52862 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52863 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52864 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52865 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52866 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52867 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52868 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52869 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52870 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52871 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52872 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52873 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52874 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52875 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52876 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52877 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52878 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52879 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52880 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52882 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52883 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52884 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52885 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52888 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52892 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52896 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52897 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52898 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52899 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52901 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52902 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52904 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52906 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52908 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52910 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52911 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52912 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52914 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52915 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52917 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52918 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52919 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52921 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52922 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52925 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52927 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52928 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52929 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52931 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52933 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52934 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52936 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52937 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52938 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52940 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52941 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52942 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52943 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52944 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52946 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52947 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52950 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52951 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52953 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52954 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52956 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52957 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52958 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52960 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52966 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52967 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52968 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52969 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52970 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52971 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52972 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52973 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52974 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52975 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52976 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52977 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52978 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52979 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52980 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52981 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52982 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52983 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52984 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52985 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52986 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52987 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52988 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52989 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52990 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52991 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52992 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52993 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52994 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52995 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52996 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52997 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52998 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52999 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53000 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53001 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53002 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53003 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53004 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53005 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53006 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53007 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53008 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53009 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53010 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53011 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53012 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53013 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53014 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53015 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53016 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53017 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53018 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53019 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53020 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53021 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53022 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53024 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53025 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53027 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53028 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53029 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53032 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53033 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53034 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53035 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53036 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53037 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53038 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53039 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53040 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53041 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53042 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53043 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53044 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53045 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53046 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53047 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53048 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53049 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53050 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53051 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53052 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53053 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53054 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53055 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53056 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53057 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53058 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53059 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53060 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53061 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53062 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53063 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53064 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53065 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53066 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53067 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53068 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53070 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53071 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53074 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53075 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53076 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53077 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53078 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53079 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53081 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53082 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53085 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53086 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53088 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53089 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53091 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53092 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53094 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53095 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53096 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53098 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53100 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53101 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53103 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53104 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53107 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53108 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53109 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53111 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53112 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53114 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53115 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53116 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53117 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53118 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53121 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53123 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53125 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53126 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53127 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53130 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53131 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53132 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53134 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53135 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53136 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53138 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53139 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53140 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53141 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53142 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53143 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53145 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53146 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53147 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53148 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53149 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53150 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53151 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53152 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53158 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53160 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53162 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53163 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53164 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53165 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53166 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53167 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53169 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53170 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53171 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53172 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53173 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53174 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53177 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53178 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53179 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53182 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53183 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53185 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53186 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53188 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53190 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53193 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53195 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53196 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53198 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53199 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53202 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53203 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53206 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53208 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53209 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53210 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53212 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53214 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53216 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53217 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53218 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53219 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53221 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53222 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53223 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53225 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53227 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53228 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53231 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53233 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53234 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53235 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53236 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53238 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53240 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53242 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53244 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53245 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53247 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53248 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53249 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53250 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53251 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53252 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53253 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53254 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53256 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53258 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53260 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53262 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53264 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53266 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53267 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53268 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53269 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53270 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53271 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53277 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53278 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53279 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53280 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53281 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53282 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53283 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53285 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53287 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53288 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53290 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53291 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53292 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53293 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53295 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53296 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53297 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53298 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53300 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53301 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53303 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53304 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53305 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53307 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53309 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53310 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53311 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53312 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53313 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53315 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53316 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53317 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53318 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53320 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53321 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53322 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53323 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53324 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53325 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53326 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53327 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53328 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53329 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53331 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53334 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53335 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53336 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53338 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53340 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53342 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53344 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53345 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53355 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53356 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53360 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53361 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53362 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53363 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53364 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53365 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53366 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53367 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53368 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53369 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53370 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53371 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53372 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53373 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53374 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53376 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53377 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53380 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53381 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53386 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53387 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53390 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53391 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53392 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53393 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53396 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53397 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53398 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53400 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53402 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53403 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53404 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53406 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53408 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53410 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53413 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53414 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53415 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53416 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53417 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53418 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53419 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53425 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53426 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53427 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53428 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53434 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53440 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53441 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53442 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53443 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53444 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53446 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53456 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53457 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53458 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53459 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53462 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53463 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53464 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53465 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53467 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53468 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53472 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53478 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53479 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53480 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53481 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53483 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53484 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53486 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53489 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53491 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53492 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53493 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53502 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53506 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53508 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53519 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53520 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53521 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53522 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53525 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53528 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53530 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53533 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53535 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53536 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53539 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53541 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53542 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53543 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53544 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53545 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53550 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53551 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53552 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53554 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53555 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53556 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53558 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53560 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53561 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53562 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53564 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53565 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53568 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53576 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53583 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53591 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53594 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53595 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53608 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53610 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53612 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53613 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53615 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53617 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53618 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53620 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53621 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53622 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53626 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53645 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53646 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53648 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53650 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53651 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53652 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53654 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53655 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53658 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53659 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53661 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53662 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53664 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53667 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53668 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53670 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53672 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53674 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53675 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53677 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53678 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53681 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53683 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53685 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53687 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53690 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53692 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53693 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53694 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53696 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53697 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53698 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53700 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53703 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53705 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53706 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53710 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53714 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53715 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53717 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53721 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53723 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53725 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53726 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53727 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53728 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53732 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53733 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53734 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53735 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53737 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53738 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53743 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53744 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53745 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53746 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53747 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53749 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53751 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53753 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53754 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53756 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53758 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53761 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53762 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53763 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53765 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53766 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53767 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53781 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53782 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53783 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53784 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53785 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53786 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53792 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53793 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53797 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53798 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53800 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53801 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53803 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53805 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53806 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53808 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53809 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53810 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53816 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53817 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53818 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53819 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53820 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53821 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53828 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53830 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53831 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53832 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53833 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53834 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53835 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53837 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53841 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53842 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53843 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53844 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53845 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53846 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53847 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53849 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53850 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53851 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53857 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53858 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53859 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53861 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53862 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53863 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53869 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53870 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53871 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53872 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53873 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53877 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53878 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53883 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53884 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53886 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53887 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53892 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53894 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53895 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53896 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53897 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53898 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53903 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53904 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53913 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53914 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53915 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53916 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53919 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53921 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53922 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53923 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53924 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53926 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53931 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53932 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53933 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53934 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53935 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53936 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53937 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53938 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53939 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53940 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53941 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53943 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53944 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53945 { NULL, NULL, 0, NULL }
53946 };
53947
53948
53949 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53950
53951 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53952 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53953 }
53954 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53955 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53956 }
53957 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53958 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53959 }
53960 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53961 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53962 }
53963 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53964 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53965 }
53966 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53967 return (void *)((wxSizer *) ((wxGridSizer *) x));
53968 }
53969 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53970 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53971 }
53972 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53973 return (void *)((wxSizer *) ((wxPySizer *) x));
53974 }
53975 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53976 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53977 }
53978 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53979 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53980 }
53981 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53982 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53983 }
53984 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53985 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53986 }
53987 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53988 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53989 }
53990 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53991 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53992 }
53993 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53994 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53995 }
53996 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53997 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53998 }
53999 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54000 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54001 }
54002 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54003 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54004 }
54005 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54006 return (void *)((wxEvent *) ((wxPyEvent *) x));
54007 }
54008 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54009 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54010 }
54011 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54012 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54013 }
54014 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54015 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54016 }
54017 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54018 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54019 }
54020 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54021 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54022 }
54023 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54024 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54025 }
54026 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54027 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54028 }
54029 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54030 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54031 }
54032 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54033 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54034 }
54035 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54036 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54037 }
54038 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54039 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54040 }
54041 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54042 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54043 }
54044 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54045 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54046 }
54047 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54048 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54049 }
54050 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54051 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54052 }
54053 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54054 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54055 }
54056 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54057 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54058 }
54059 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54060 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54061 }
54062 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54063 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54064 }
54065 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54066 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54067 }
54068 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54069 return (void *)((wxEvent *) ((wxShowEvent *) x));
54070 }
54071 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54072 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54073 }
54074 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54075 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54076 }
54077 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54078 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54079 }
54080 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54081 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54082 }
54083 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54084 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54085 }
54086 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54087 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54088 }
54089 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54090 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54091 }
54092 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54093 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54094 }
54095 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54096 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54097 }
54098 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54099 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54100 }
54101 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54102 return (void *)((wxControl *) ((wxControlWithItems *) x));
54103 }
54104 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54105 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54106 }
54107 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54108 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54109 }
54110 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54111 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54112 }
54113 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54114 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54115 }
54116 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54117 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54118 }
54119 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54120 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54121 }
54122 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54123 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54124 }
54125 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54126 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54127 }
54128 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54129 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54130 }
54131 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54132 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54133 }
54134 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54135 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54136 }
54137 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54138 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54139 }
54140 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54141 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54142 }
54143 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54144 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54145 }
54146 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54147 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54148 }
54149 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54150 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54151 }
54152 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54153 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54154 }
54155 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54156 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54157 }
54158 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54159 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54160 }
54161 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54162 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54163 }
54164 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54165 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54166 }
54167 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54168 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54169 }
54170 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54171 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54172 }
54173 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54174 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54175 }
54176 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54177 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54178 }
54179 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54180 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54181 }
54182 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54183 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54184 }
54185 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54186 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54187 }
54188 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54189 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54190 }
54191 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54192 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54193 }
54194 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54195 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54196 }
54197 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54198 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54199 }
54200 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54201 return (void *)((wxObject *) ((wxSizerItem *) x));
54202 }
54203 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54204 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54205 }
54206 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54207 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54208 }
54209 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54210 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54211 }
54212 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54213 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54214 }
54215 static void *_p_wxSizerTo_p_wxObject(void *x) {
54216 return (void *)((wxObject *) ((wxSizer *) x));
54217 }
54218 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54219 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54220 }
54221 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54222 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54223 }
54224 static void *_p_wxEventTo_p_wxObject(void *x) {
54225 return (void *)((wxObject *) ((wxEvent *) x));
54226 }
54227 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54228 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54229 }
54230 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54231 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54232 }
54233 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54234 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54235 }
54236 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54237 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54238 }
54239 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54240 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54241 }
54242 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54243 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54244 }
54245 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54246 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54247 }
54248 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54249 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54250 }
54251 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54252 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54253 }
54254 static void *_p_wxControlTo_p_wxObject(void *x) {
54255 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54256 }
54257 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54258 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54259 }
54260 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54261 return (void *)((wxObject *) ((wxFSFile *) x));
54262 }
54263 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54264 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54265 }
54266 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54267 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54268 }
54269 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54270 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54271 }
54272 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54273 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54274 }
54275 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54276 return (void *)((wxObject *) ((wxMenuItem *) x));
54277 }
54278 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54279 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54280 }
54281 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54282 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54283 }
54284 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54285 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54286 }
54287 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54288 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54289 }
54290 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54291 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54292 }
54293 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54294 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54295 }
54296 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54297 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54298 }
54299 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54300 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54301 }
54302 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54303 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54304 }
54305 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54306 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54307 }
54308 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54309 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54310 }
54311 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54312 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54313 }
54314 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54315 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54316 }
54317 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54318 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54319 }
54320 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54321 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54322 }
54323 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54324 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54325 }
54326 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54327 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54328 }
54329 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54330 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54331 }
54332 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54333 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54334 }
54335 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54336 return (void *)((wxObject *) ((wxImageHandler *) x));
54337 }
54338 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54339 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54340 }
54341 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54342 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54343 }
54344 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54345 return (void *)((wxObject *) ((wxEvtHandler *) x));
54346 }
54347 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54348 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54349 }
54350 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54351 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54352 }
54353 static void *_p_wxImageTo_p_wxObject(void *x) {
54354 return (void *)((wxObject *) ((wxImage *) x));
54355 }
54356 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54357 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54358 }
54359 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54360 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54361 }
54362 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54363 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54364 }
54365 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54366 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54367 }
54368 static void *_p_wxWindowTo_p_wxObject(void *x) {
54369 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54370 }
54371 static void *_p_wxMenuTo_p_wxObject(void *x) {
54372 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54373 }
54374 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54375 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54376 }
54377 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54378 return (void *)((wxObject *) ((wxFileSystem *) x));
54379 }
54380 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54381 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54382 }
54383 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54384 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54385 }
54386 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54387 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54388 }
54389 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54390 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54391 }
54392 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54393 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54394 }
54395 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54396 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54397 }
54398 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54399 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54400 }
54401 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54402 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54403 }
54404 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54405 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54406 }
54407 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54408 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54409 }
54410 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54411 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54412 }
54413 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54414 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54415 }
54416 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54417 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54418 }
54419 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54420 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54421 }
54422 static void *_p_wxControlTo_p_wxWindow(void *x) {
54423 return (void *)((wxWindow *) ((wxControl *) x));
54424 }
54425 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54426 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54427 }
54428 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54429 return (void *)((wxWindow *) ((wxMenuBar *) x));
54430 }
54431 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54432 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54433 }
54434 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54435 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54436 }
54437 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54438 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54439 }
54440 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54441 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54442 }
54443 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54444 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54445 }
54446 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54447 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54448 }
54449 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54450 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54451 }
54452 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54453 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54454 }
54455 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54456 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54457 }
54458 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54459 return (void *)((wxValidator *) ((wxPyValidator *) x));
54460 }
54461 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54463 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};
54464 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54486 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54487 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54488 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54489 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54490 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54491 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54492 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54493 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54494 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54495 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54496 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54497 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54498 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54499 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54500 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54501 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54502 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54503 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54504 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54505 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54506 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54507 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54508 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54509 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54510 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54511 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54512 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54513 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54514 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54515 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54516 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54517 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54518 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54519 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54520 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54521 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54522 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54523 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54524 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54525 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54526 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54527 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54528 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54529 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54530 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54531 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54532 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54533 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54534 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54535 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54536 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54537 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54538 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54539 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54540 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54541 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54543 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54544 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54590
54591 static swig_type_info *swig_type_initial[] = {
54592 &_swigt__p_buffer,
54593 &_swigt__p_char,
54594 &_swigt__p_form_ops_t,
54595 &_swigt__p_int,
54596 &_swigt__p_long,
54597 &_swigt__p_unsigned_char,
54598 &_swigt__p_unsigned_int,
54599 &_swigt__p_unsigned_long,
54600 &_swigt__p_wxANIHandler,
54601 &_swigt__p_wxAcceleratorEntry,
54602 &_swigt__p_wxAcceleratorTable,
54603 &_swigt__p_wxActivateEvent,
54604 &_swigt__p_wxAppTraits,
54605 &_swigt__p_wxArrayString,
54606 &_swigt__p_wxBMPHandler,
54607 &_swigt__p_wxBitmap,
54608 &_swigt__p_wxBoxSizer,
54609 &_swigt__p_wxButton,
54610 &_swigt__p_wxCURHandler,
54611 &_swigt__p_wxCaret,
54612 &_swigt__p_wxChildFocusEvent,
54613 &_swigt__p_wxCloseEvent,
54614 &_swigt__p_wxColour,
54615 &_swigt__p_wxCommandEvent,
54616 &_swigt__p_wxContextMenuEvent,
54617 &_swigt__p_wxControl,
54618 &_swigt__p_wxControlWithItems,
54619 &_swigt__p_wxCursor,
54620 &_swigt__p_wxDC,
54621 &_swigt__p_wxDateEvent,
54622 &_swigt__p_wxDateTime,
54623 &_swigt__p_wxDisplayChangedEvent,
54624 &_swigt__p_wxDropFilesEvent,
54625 &_swigt__p_wxDuplexMode,
54626 &_swigt__p_wxEraseEvent,
54627 &_swigt__p_wxEvent,
54628 &_swigt__p_wxEventLoop,
54629 &_swigt__p_wxEventLoopActivator,
54630 &_swigt__p_wxEvtHandler,
54631 &_swigt__p_wxFSFile,
54632 &_swigt__p_wxFileSystem,
54633 &_swigt__p_wxFileSystemHandler,
54634 &_swigt__p_wxFlexGridSizer,
54635 &_swigt__p_wxFocusEvent,
54636 &_swigt__p_wxFont,
54637 &_swigt__p_wxFrame,
54638 &_swigt__p_wxGBPosition,
54639 &_swigt__p_wxGBSizerItem,
54640 &_swigt__p_wxGBSpan,
54641 &_swigt__p_wxGIFHandler,
54642 &_swigt__p_wxGridBagSizer,
54643 &_swigt__p_wxGridSizer,
54644 &_swigt__p_wxICOHandler,
54645 &_swigt__p_wxIconizeEvent,
54646 &_swigt__p_wxIdleEvent,
54647 &_swigt__p_wxImage,
54648 &_swigt__p_wxImageHandler,
54649 &_swigt__p_wxImageHistogram,
54650 &_swigt__p_wxImage_HSVValue,
54651 &_swigt__p_wxImage_RGBValue,
54652 &_swigt__p_wxIndividualLayoutConstraint,
54653 &_swigt__p_wxInitDialogEvent,
54654 &_swigt__p_wxInputStream,
54655 &_swigt__p_wxInternetFSHandler,
54656 &_swigt__p_wxItemContainer,
54657 &_swigt__p_wxJPEGHandler,
54658 &_swigt__p_wxKeyEvent,
54659 &_swigt__p_wxLayoutConstraints,
54660 &_swigt__p_wxMaximizeEvent,
54661 &_swigt__p_wxMemoryFSHandler,
54662 &_swigt__p_wxMenu,
54663 &_swigt__p_wxMenuBar,
54664 &_swigt__p_wxMenuBarBase,
54665 &_swigt__p_wxMenuEvent,
54666 &_swigt__p_wxMenuItem,
54667 &_swigt__p_wxMouseCaptureChangedEvent,
54668 &_swigt__p_wxMouseEvent,
54669 &_swigt__p_wxMoveEvent,
54670 &_swigt__p_wxNavigationKeyEvent,
54671 &_swigt__p_wxNcPaintEvent,
54672 &_swigt__p_wxNotifyEvent,
54673 &_swigt__p_wxObject,
54674 &_swigt__p_wxOutputStream,
54675 &_swigt__p_wxPCXHandler,
54676 &_swigt__p_wxPNGHandler,
54677 &_swigt__p_wxPNMHandler,
54678 &_swigt__p_wxPaintEvent,
54679 &_swigt__p_wxPaletteChangedEvent,
54680 &_swigt__p_wxPaperSize,
54681 &_swigt__p_wxPoint,
54682 &_swigt__p_wxPoint2D,
54683 &_swigt__p_wxPropagateOnce,
54684 &_swigt__p_wxPropagationDisabler,
54685 &_swigt__p_wxPyApp,
54686 &_swigt__p_wxPyCommandEvent,
54687 &_swigt__p_wxPyDropTarget,
54688 &_swigt__p_wxPyEvent,
54689 &_swigt__p_wxPyFileSystemHandler,
54690 &_swigt__p_wxPyImageHandler,
54691 &_swigt__p_wxPyInputStream,
54692 &_swigt__p_wxPySizer,
54693 &_swigt__p_wxPyValidator,
54694 &_swigt__p_wxQuantize,
54695 &_swigt__p_wxQueryNewPaletteEvent,
54696 &_swigt__p_wxRealPoint,
54697 &_swigt__p_wxRect,
54698 &_swigt__p_wxRegion,
54699 &_swigt__p_wxScrollEvent,
54700 &_swigt__p_wxScrollWinEvent,
54701 &_swigt__p_wxSetCursorEvent,
54702 &_swigt__p_wxShowEvent,
54703 &_swigt__p_wxSize,
54704 &_swigt__p_wxSizeEvent,
54705 &_swigt__p_wxSizer,
54706 &_swigt__p_wxSizerItem,
54707 &_swigt__p_wxStaticBox,
54708 &_swigt__p_wxStaticBoxSizer,
54709 &_swigt__p_wxStdDialogButtonSizer,
54710 &_swigt__p_wxSysColourChangedEvent,
54711 &_swigt__p_wxTIFFHandler,
54712 &_swigt__p_wxToolTip,
54713 &_swigt__p_wxUpdateUIEvent,
54714 &_swigt__p_wxValidator,
54715 &_swigt__p_wxVisualAttributes,
54716 &_swigt__p_wxWindow,
54717 &_swigt__p_wxWindowCreateEvent,
54718 &_swigt__p_wxWindowDestroyEvent,
54719 &_swigt__p_wxXPMHandler,
54720 &_swigt__p_wxZipFSHandler,
54721 };
54722
54723 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54733 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54734 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54736 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54737 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}};
54738 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54739 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}};
54740 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54741 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}};
54742 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54743 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54744 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54746 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_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}};
54747 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54748 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}};
54749 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54750 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54751 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54752 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54753 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54754 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54755 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54756 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54757 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54758 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_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}};
54759 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54760 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54761 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}};
54762 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54763 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54764 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}};
54765 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}};
54766 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54767 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54768 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54769 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54770 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54771 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54772 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54773 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54774 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}};
54775 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}};
54776 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54777 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54778 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54779 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}};
54780 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54781 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54782 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54783 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54784 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54785 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54786 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54787 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}};
54788 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54789 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54790 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54791 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54792 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54793 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54794 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54795 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54796 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54797 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54798 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54799 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54800 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54801 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54802 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54803 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54804 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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_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_wxPNMHandler, _p_wxPNMHandlerTo_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_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}};
54805 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54819 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54820 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54821 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54822 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54823 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54824 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54829 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54830 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54831 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54832 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54836 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}};
54837 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}};
54838 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54841 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54842 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54844 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54845 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}};
54846 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54847 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}};
54848 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54849 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54850 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54852
54853 static swig_cast_info *swig_cast_initial[] = {
54854 _swigc__p_buffer,
54855 _swigc__p_char,
54856 _swigc__p_form_ops_t,
54857 _swigc__p_int,
54858 _swigc__p_long,
54859 _swigc__p_unsigned_char,
54860 _swigc__p_unsigned_int,
54861 _swigc__p_unsigned_long,
54862 _swigc__p_wxANIHandler,
54863 _swigc__p_wxAcceleratorEntry,
54864 _swigc__p_wxAcceleratorTable,
54865 _swigc__p_wxActivateEvent,
54866 _swigc__p_wxAppTraits,
54867 _swigc__p_wxArrayString,
54868 _swigc__p_wxBMPHandler,
54869 _swigc__p_wxBitmap,
54870 _swigc__p_wxBoxSizer,
54871 _swigc__p_wxButton,
54872 _swigc__p_wxCURHandler,
54873 _swigc__p_wxCaret,
54874 _swigc__p_wxChildFocusEvent,
54875 _swigc__p_wxCloseEvent,
54876 _swigc__p_wxColour,
54877 _swigc__p_wxCommandEvent,
54878 _swigc__p_wxContextMenuEvent,
54879 _swigc__p_wxControl,
54880 _swigc__p_wxControlWithItems,
54881 _swigc__p_wxCursor,
54882 _swigc__p_wxDC,
54883 _swigc__p_wxDateEvent,
54884 _swigc__p_wxDateTime,
54885 _swigc__p_wxDisplayChangedEvent,
54886 _swigc__p_wxDropFilesEvent,
54887 _swigc__p_wxDuplexMode,
54888 _swigc__p_wxEraseEvent,
54889 _swigc__p_wxEvent,
54890 _swigc__p_wxEventLoop,
54891 _swigc__p_wxEventLoopActivator,
54892 _swigc__p_wxEvtHandler,
54893 _swigc__p_wxFSFile,
54894 _swigc__p_wxFileSystem,
54895 _swigc__p_wxFileSystemHandler,
54896 _swigc__p_wxFlexGridSizer,
54897 _swigc__p_wxFocusEvent,
54898 _swigc__p_wxFont,
54899 _swigc__p_wxFrame,
54900 _swigc__p_wxGBPosition,
54901 _swigc__p_wxGBSizerItem,
54902 _swigc__p_wxGBSpan,
54903 _swigc__p_wxGIFHandler,
54904 _swigc__p_wxGridBagSizer,
54905 _swigc__p_wxGridSizer,
54906 _swigc__p_wxICOHandler,
54907 _swigc__p_wxIconizeEvent,
54908 _swigc__p_wxIdleEvent,
54909 _swigc__p_wxImage,
54910 _swigc__p_wxImageHandler,
54911 _swigc__p_wxImageHistogram,
54912 _swigc__p_wxImage_HSVValue,
54913 _swigc__p_wxImage_RGBValue,
54914 _swigc__p_wxIndividualLayoutConstraint,
54915 _swigc__p_wxInitDialogEvent,
54916 _swigc__p_wxInputStream,
54917 _swigc__p_wxInternetFSHandler,
54918 _swigc__p_wxItemContainer,
54919 _swigc__p_wxJPEGHandler,
54920 _swigc__p_wxKeyEvent,
54921 _swigc__p_wxLayoutConstraints,
54922 _swigc__p_wxMaximizeEvent,
54923 _swigc__p_wxMemoryFSHandler,
54924 _swigc__p_wxMenu,
54925 _swigc__p_wxMenuBar,
54926 _swigc__p_wxMenuBarBase,
54927 _swigc__p_wxMenuEvent,
54928 _swigc__p_wxMenuItem,
54929 _swigc__p_wxMouseCaptureChangedEvent,
54930 _swigc__p_wxMouseEvent,
54931 _swigc__p_wxMoveEvent,
54932 _swigc__p_wxNavigationKeyEvent,
54933 _swigc__p_wxNcPaintEvent,
54934 _swigc__p_wxNotifyEvent,
54935 _swigc__p_wxObject,
54936 _swigc__p_wxOutputStream,
54937 _swigc__p_wxPCXHandler,
54938 _swigc__p_wxPNGHandler,
54939 _swigc__p_wxPNMHandler,
54940 _swigc__p_wxPaintEvent,
54941 _swigc__p_wxPaletteChangedEvent,
54942 _swigc__p_wxPaperSize,
54943 _swigc__p_wxPoint,
54944 _swigc__p_wxPoint2D,
54945 _swigc__p_wxPropagateOnce,
54946 _swigc__p_wxPropagationDisabler,
54947 _swigc__p_wxPyApp,
54948 _swigc__p_wxPyCommandEvent,
54949 _swigc__p_wxPyDropTarget,
54950 _swigc__p_wxPyEvent,
54951 _swigc__p_wxPyFileSystemHandler,
54952 _swigc__p_wxPyImageHandler,
54953 _swigc__p_wxPyInputStream,
54954 _swigc__p_wxPySizer,
54955 _swigc__p_wxPyValidator,
54956 _swigc__p_wxQuantize,
54957 _swigc__p_wxQueryNewPaletteEvent,
54958 _swigc__p_wxRealPoint,
54959 _swigc__p_wxRect,
54960 _swigc__p_wxRegion,
54961 _swigc__p_wxScrollEvent,
54962 _swigc__p_wxScrollWinEvent,
54963 _swigc__p_wxSetCursorEvent,
54964 _swigc__p_wxShowEvent,
54965 _swigc__p_wxSize,
54966 _swigc__p_wxSizeEvent,
54967 _swigc__p_wxSizer,
54968 _swigc__p_wxSizerItem,
54969 _swigc__p_wxStaticBox,
54970 _swigc__p_wxStaticBoxSizer,
54971 _swigc__p_wxStdDialogButtonSizer,
54972 _swigc__p_wxSysColourChangedEvent,
54973 _swigc__p_wxTIFFHandler,
54974 _swigc__p_wxToolTip,
54975 _swigc__p_wxUpdateUIEvent,
54976 _swigc__p_wxValidator,
54977 _swigc__p_wxVisualAttributes,
54978 _swigc__p_wxWindow,
54979 _swigc__p_wxWindowCreateEvent,
54980 _swigc__p_wxWindowDestroyEvent,
54981 _swigc__p_wxXPMHandler,
54982 _swigc__p_wxZipFSHandler,
54983 };
54984
54985
54986 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54987
54988 static swig_const_info swig_const_table[] = {
54989 {0, 0, 0, 0.0, 0, 0}};
54990
54991 #ifdef __cplusplus
54992 }
54993 #endif
54994 /* -----------------------------------------------------------------------------
54995 * Type initialization:
54996 * This problem is tough by the requirement that no dynamic
54997 * memory is used. Also, since swig_type_info structures store pointers to
54998 * swig_cast_info structures and swig_cast_info structures store pointers back
54999 * to swig_type_info structures, we need some lookup code at initialization.
55000 * The idea is that swig generates all the structures that are needed.
55001 * The runtime then collects these partially filled structures.
55002 * The SWIG_InitializeModule function takes these initial arrays out of
55003 * swig_module, and does all the lookup, filling in the swig_module.types
55004 * array with the correct data and linking the correct swig_cast_info
55005 * structures together.
55006 *
55007 * The generated swig_type_info structures are assigned staticly to an initial
55008 * array. We just loop though that array, and handle each type individually.
55009 * First we lookup if this type has been already loaded, and if so, use the
55010 * loaded structure instead of the generated one. Then we have to fill in the
55011 * cast linked list. The cast data is initially stored in something like a
55012 * two-dimensional array. Each row corresponds to a type (there are the same
55013 * number of rows as there are in the swig_type_initial array). Each entry in
55014 * a column is one of the swig_cast_info structures for that type.
55015 * The cast_initial array is actually an array of arrays, because each row has
55016 * a variable number of columns. So to actually build the cast linked list,
55017 * we find the array of casts associated with the type, and loop through it
55018 * adding the casts to the list. The one last trick we need to do is making
55019 * sure the type pointer in the swig_cast_info struct is correct.
55020 *
55021 * First off, we lookup the cast->type name to see if it is already loaded.
55022 * There are three cases to handle:
55023 * 1) If the cast->type has already been loaded AND the type we are adding
55024 * casting info to has not been loaded (it is in this module), THEN we
55025 * replace the cast->type pointer with the type pointer that has already
55026 * been loaded.
55027 * 2) If BOTH types (the one we are adding casting info to, and the
55028 * cast->type) are loaded, THEN the cast info has already been loaded by
55029 * the previous module so we just ignore it.
55030 * 3) Finally, if cast->type has not already been loaded, then we add that
55031 * swig_cast_info to the linked list (because the cast->type) pointer will
55032 * be correct.
55033 * ----------------------------------------------------------------------------- */
55034
55035 #ifdef __cplusplus
55036 extern "C" {
55037 #if 0
55038 } /* c-mode */
55039 #endif
55040 #endif
55041
55042 #if 0
55043 #define SWIGRUNTIME_DEBUG
55044 #endif
55045
55046 SWIGRUNTIME void
55047 SWIG_InitializeModule(void *clientdata) {
55048 size_t i;
55049 swig_module_info *module_head;
55050 static int init_run = 0;
55051
55052 clientdata = clientdata;
55053
55054 if (init_run) return;
55055 init_run = 1;
55056
55057 /* Initialize the swig_module */
55058 swig_module.type_initial = swig_type_initial;
55059 swig_module.cast_initial = swig_cast_initial;
55060
55061 /* Try and load any already created modules */
55062 module_head = SWIG_GetModule(clientdata);
55063 if (module_head) {
55064 swig_module.next = module_head->next;
55065 module_head->next = &swig_module;
55066 } else {
55067 /* This is the first module loaded */
55068 swig_module.next = &swig_module;
55069 SWIG_SetModule(clientdata, &swig_module);
55070 }
55071
55072 /* Now work on filling in swig_module.types */
55073 #ifdef SWIGRUNTIME_DEBUG
55074 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55075 #endif
55076 for (i = 0; i < swig_module.size; ++i) {
55077 swig_type_info *type = 0;
55078 swig_type_info *ret;
55079 swig_cast_info *cast;
55080
55081 #ifdef SWIGRUNTIME_DEBUG
55082 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55083 #endif
55084
55085 /* if there is another module already loaded */
55086 if (swig_module.next != &swig_module) {
55087 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55088 }
55089 if (type) {
55090 /* Overwrite clientdata field */
55091 #ifdef SWIGRUNTIME_DEBUG
55092 printf("SWIG_InitializeModule: found type %s\n", type->name);
55093 #endif
55094 if (swig_module.type_initial[i]->clientdata) {
55095 type->clientdata = swig_module.type_initial[i]->clientdata;
55096 #ifdef SWIGRUNTIME_DEBUG
55097 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55098 #endif
55099 }
55100 } else {
55101 type = swig_module.type_initial[i];
55102 }
55103
55104 /* Insert casting types */
55105 cast = swig_module.cast_initial[i];
55106 while (cast->type) {
55107 /* Don't need to add information already in the list */
55108 ret = 0;
55109 #ifdef SWIGRUNTIME_DEBUG
55110 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55111 #endif
55112 if (swig_module.next != &swig_module) {
55113 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55114 #ifdef SWIGRUNTIME_DEBUG
55115 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55116 #endif
55117 }
55118 if (ret) {
55119 if (type == swig_module.type_initial[i]) {
55120 #ifdef SWIGRUNTIME_DEBUG
55121 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55122 #endif
55123 cast->type = ret;
55124 ret = 0;
55125 } else {
55126 /* Check for casting already in the list */
55127 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55128 #ifdef SWIGRUNTIME_DEBUG
55129 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55130 #endif
55131 if (!ocast) ret = 0;
55132 }
55133 }
55134
55135 if (!ret) {
55136 #ifdef SWIGRUNTIME_DEBUG
55137 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55138 #endif
55139 if (type->cast) {
55140 type->cast->prev = cast;
55141 cast->next = type->cast;
55142 }
55143 type->cast = cast;
55144 }
55145 cast++;
55146 }
55147 /* Set entry in modules->types array equal to the type */
55148 swig_module.types[i] = type;
55149 }
55150 swig_module.types[i] = 0;
55151
55152 #ifdef SWIGRUNTIME_DEBUG
55153 printf("**** SWIG_InitializeModule: Cast List ******\n");
55154 for (i = 0; i < swig_module.size; ++i) {
55155 int j = 0;
55156 swig_cast_info *cast = swig_module.cast_initial[i];
55157 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55158 while (cast->type) {
55159 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55160 cast++;
55161 ++j;
55162 }
55163 printf("---- Total casts: %d\n",j);
55164 }
55165 printf("**** SWIG_InitializeModule: Cast List ******\n");
55166 #endif
55167 }
55168
55169 /* This function will propagate the clientdata field of type to
55170 * any new swig_type_info structures that have been added into the list
55171 * of equivalent types. It is like calling
55172 * SWIG_TypeClientData(type, clientdata) a second time.
55173 */
55174 SWIGRUNTIME void
55175 SWIG_PropagateClientData(void) {
55176 size_t i;
55177 swig_cast_info *equiv;
55178 static int init_run = 0;
55179
55180 if (init_run) return;
55181 init_run = 1;
55182
55183 for (i = 0; i < swig_module.size; i++) {
55184 if (swig_module.types[i]->clientdata) {
55185 equiv = swig_module.types[i]->cast;
55186 while (equiv) {
55187 if (!equiv->converter) {
55188 if (equiv->type && !equiv->type->clientdata)
55189 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55190 }
55191 equiv = equiv->next;
55192 }
55193 }
55194 }
55195 }
55196
55197 #ifdef __cplusplus
55198 #if 0
55199 {
55200 /* c-mode */
55201 #endif
55202 }
55203 #endif
55204
55205
55206
55207 #ifdef __cplusplus
55208 extern "C" {
55209 #endif
55210
55211 /* Python-specific SWIG API */
55212 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55213 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55214 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55215
55216 /* -----------------------------------------------------------------------------
55217 * global variable support code.
55218 * ----------------------------------------------------------------------------- */
55219
55220 typedef struct swig_globalvar {
55221 char *name; /* Name of global variable */
55222 PyObject *(*get_attr)(void); /* Return the current value */
55223 int (*set_attr)(PyObject *); /* Set the value */
55224 struct swig_globalvar *next;
55225 } swig_globalvar;
55226
55227 typedef struct swig_varlinkobject {
55228 PyObject_HEAD
55229 swig_globalvar *vars;
55230 } swig_varlinkobject;
55231
55232 SWIGINTERN PyObject *
55233 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55234 return PyString_FromString("<Swig global variables>");
55235 }
55236
55237 SWIGINTERN PyObject *
55238 swig_varlink_str(swig_varlinkobject *v) {
55239 PyObject *str = PyString_FromString("(");
55240 swig_globalvar *var;
55241 for (var = v->vars; var; var=var->next) {
55242 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55243 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55244 }
55245 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55246 return str;
55247 }
55248
55249 SWIGINTERN int
55250 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55251 PyObject *str = swig_varlink_str(v);
55252 fprintf(fp,"Swig global variables ");
55253 fprintf(fp,"%s\n", PyString_AsString(str));
55254 Py_DECREF(str);
55255 return 0;
55256 }
55257
55258 SWIGINTERN void
55259 swig_varlink_dealloc(swig_varlinkobject *v) {
55260 swig_globalvar *var = v->vars;
55261 while (var) {
55262 swig_globalvar *n = var->next;
55263 free(var->name);
55264 free(var);
55265 var = n;
55266 }
55267 }
55268
55269 SWIGINTERN PyObject *
55270 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55271 PyObject *res = NULL;
55272 swig_globalvar *var = v->vars;
55273 while (var) {
55274 if (strcmp(var->name,n) == 0) {
55275 res = (*var->get_attr)();
55276 break;
55277 }
55278 var = var->next;
55279 }
55280 if (res == NULL && !PyErr_Occurred()) {
55281 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55282 }
55283 return res;
55284 }
55285
55286 SWIGINTERN int
55287 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55288 int res = 1;
55289 swig_globalvar *var = v->vars;
55290 while (var) {
55291 if (strcmp(var->name,n) == 0) {
55292 res = (*var->set_attr)(p);
55293 break;
55294 }
55295 var = var->next;
55296 }
55297 if (res == 1 && !PyErr_Occurred()) {
55298 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55299 }
55300 return res;
55301 }
55302
55303 SWIGINTERN PyTypeObject*
55304 swig_varlink_type(void) {
55305 static char varlink__doc__[] = "Swig var link object";
55306 static PyTypeObject varlink_type;
55307 static int type_init = 0;
55308 if (!type_init) {
55309 const PyTypeObject tmp
55310 = {
55311 PyObject_HEAD_INIT(NULL)
55312 0, /* Number of items in variable part (ob_size) */
55313 (char *)"swigvarlink", /* Type name (tp_name) */
55314 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55315 0, /* Itemsize (tp_itemsize) */
55316 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55317 (printfunc) swig_varlink_print, /* Print (tp_print) */
55318 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55319 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55320 0, /* tp_compare */
55321 (reprfunc) swig_varlink_repr, /* tp_repr */
55322 0, /* tp_as_number */
55323 0, /* tp_as_sequence */
55324 0, /* tp_as_mapping */
55325 0, /* tp_hash */
55326 0, /* tp_call */
55327 (reprfunc)swig_varlink_str, /* tp_str */
55328 0, /* tp_getattro */
55329 0, /* tp_setattro */
55330 0, /* tp_as_buffer */
55331 0, /* tp_flags */
55332 varlink__doc__, /* tp_doc */
55333 0, /* tp_traverse */
55334 0, /* tp_clear */
55335 0, /* tp_richcompare */
55336 0, /* tp_weaklistoffset */
55337 #if PY_VERSION_HEX >= 0x02020000
55338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55339 #endif
55340 #if PY_VERSION_HEX >= 0x02030000
55341 0, /* tp_del */
55342 #endif
55343 #ifdef COUNT_ALLOCS
55344 0,0,0,0 /* tp_alloc -> tp_next */
55345 #endif
55346 };
55347 varlink_type = tmp;
55348 varlink_type.ob_type = &PyType_Type;
55349 type_init = 1;
55350 }
55351 return &varlink_type;
55352 }
55353
55354 /* Create a variable linking object for use later */
55355 SWIGINTERN PyObject *
55356 SWIG_Python_newvarlink(void) {
55357 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55358 if (result) {
55359 result->vars = 0;
55360 }
55361 return ((PyObject*) result);
55362 }
55363
55364 SWIGINTERN void
55365 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55366 swig_varlinkobject *v = (swig_varlinkobject *) p;
55367 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55368 if (gv) {
55369 size_t size = strlen(name)+1;
55370 gv->name = (char *)malloc(size);
55371 if (gv->name) {
55372 strncpy(gv->name,name,size);
55373 gv->get_attr = get_attr;
55374 gv->set_attr = set_attr;
55375 gv->next = v->vars;
55376 }
55377 }
55378 v->vars = gv;
55379 }
55380
55381 SWIGINTERN PyObject *
55382 SWIG_globals() {
55383 static PyObject *_SWIG_globals = 0;
55384 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55385 return _SWIG_globals;
55386 }
55387
55388 /* -----------------------------------------------------------------------------
55389 * constants/methods manipulation
55390 * ----------------------------------------------------------------------------- */
55391
55392 /* Install Constants */
55393 SWIGINTERN void
55394 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55395 PyObject *obj = 0;
55396 size_t i;
55397 for (i = 0; constants[i].type; ++i) {
55398 switch(constants[i].type) {
55399 case SWIG_PY_POINTER:
55400 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55401 break;
55402 case SWIG_PY_BINARY:
55403 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55404 break;
55405 default:
55406 obj = 0;
55407 break;
55408 }
55409 if (obj) {
55410 PyDict_SetItemString(d, constants[i].name, obj);
55411 Py_DECREF(obj);
55412 }
55413 }
55414 }
55415
55416 /* -----------------------------------------------------------------------------*/
55417 /* Fix SwigMethods to carry the callback ptrs when needed */
55418 /* -----------------------------------------------------------------------------*/
55419
55420 SWIGINTERN void
55421 SWIG_Python_FixMethods(PyMethodDef *methods,
55422 swig_const_info *const_table,
55423 swig_type_info **types,
55424 swig_type_info **types_initial) {
55425 size_t i;
55426 for (i = 0; methods[i].ml_name; ++i) {
55427 char *c = methods[i].ml_doc;
55428 if (c && (c = strstr(c, "swig_ptr: "))) {
55429 int j;
55430 swig_const_info *ci = 0;
55431 char *name = c + 10;
55432 for (j = 0; const_table[j].type; ++j) {
55433 if (strncmp(const_table[j].name, name,
55434 strlen(const_table[j].name)) == 0) {
55435 ci = &(const_table[j]);
55436 break;
55437 }
55438 }
55439 if (ci) {
55440 size_t shift = (ci->ptype) - types;
55441 swig_type_info *ty = types_initial[shift];
55442 size_t ldoc = (c - methods[i].ml_doc);
55443 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55444 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55445 if (ndoc) {
55446 char *buff = ndoc;
55447 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55448 if (ptr) {
55449 strncpy(buff, methods[i].ml_doc, ldoc);
55450 buff += ldoc;
55451 strncpy(buff, "swig_ptr: ", 10);
55452 buff += 10;
55453 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55454 methods[i].ml_doc = ndoc;
55455 }
55456 }
55457 }
55458 }
55459 }
55460 }
55461
55462 #ifdef __cplusplus
55463 }
55464 #endif
55465
55466 /* -----------------------------------------------------------------------------*
55467 * Partial Init method
55468 * -----------------------------------------------------------------------------*/
55469
55470 #ifdef __cplusplus
55471 extern "C"
55472 #endif
55473 SWIGEXPORT void SWIG_init(void) {
55474 PyObject *m, *d;
55475
55476 /* Fix SwigMethods to carry the callback ptrs when needed */
55477 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55478
55479 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55480 d = PyModule_GetDict(m);
55481
55482 SWIG_InitializeModule(0);
55483 SWIG_InstallConstants(d,swig_const_table);
55484
55485
55486
55487 #ifndef wxPyUSE_EXPORT
55488 // Make our API structure a CObject so other modules can import it
55489 // from this module.
55490 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55491 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55492 Py_XDECREF(cobj);
55493 #endif
55494
55495 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55496 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55497 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55498 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55499 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55500 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55501 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55502 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55503 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55504 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55505 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55506 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55507 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55508 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55509 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55510 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55511 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55512 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55513 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55514 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55515 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55516 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55517 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55518 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55519 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55520 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55521 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55522 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55523 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55524 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55525 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55526 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55527 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55528 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55529 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55530 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55531 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55532 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55533 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55534 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55535 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55536 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55537 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55538 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55539 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55540 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55541 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55542 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55543 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55544 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55545 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55546 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55547 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55548 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55549 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55550 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55551 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55552 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55553 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55554 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55555 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55556 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55557 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55558 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55559 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55560 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55561 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55562 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55563 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55564 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55565 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55566 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55567 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55568 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55569 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55570 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55571 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55572 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55573 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55574 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55575 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55576 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55577 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55578 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55579 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55580 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55581 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55582 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55583 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55584 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55585 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55586 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55587 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55588 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55589 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55590 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55591 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55592 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55593 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55594 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55595 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55596 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55597 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55598 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55599 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55600 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55601 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55602 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55603 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55604 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55605 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55606 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55607 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55608 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55609 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55610 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55611 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55612 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55613 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55614 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55615 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55616 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55617 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55618 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55619 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55620 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55621 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55622 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55623 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55624 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55625 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55626 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55627 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55628 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55629 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55630 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55631 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55632 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55633 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55634 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55635 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55636 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55637 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55638 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55639 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55640 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55641 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55642 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55643 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55644 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55645 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55646 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55647 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55648 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55649 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55650 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55651 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55652 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55653 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55654 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55655 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55656 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55657 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55658 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55659 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55660 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55661 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55662 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55663 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55664 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55665 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55666 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55667 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55668 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55669 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55670 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55671 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55672 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55673 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55674 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55675 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55676 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55677 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55678 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55679 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55680 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55681 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55682 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55683 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55684 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55685 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55686 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55687 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55688 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55689 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55690 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55691 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55692 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55693 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55694 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55695 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55696 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55697 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55698 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55699 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55700 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55701 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55702 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55703 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55704 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55705 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55706 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55707 SWIG_Python_SetConstant(d, "DD_CHANGE_DIR",SWIG_From_int(static_cast< int >(wxDD_CHANGE_DIR)));
55708 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55709 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55710 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55711 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55712 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55713 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55714 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55715 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55716 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55717 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55718 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55719 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55720 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55721 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55722 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55723 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55724 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55725 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55726 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55727 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55728 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55729 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55730 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55731 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55732 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55733 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55734 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55735 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55736 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55737 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55738 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55739 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55740 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55741 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55742 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55743 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55744 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55745 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55746 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55747 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55748 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55749 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55750 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55751 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55752 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55753 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55754 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55755 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55756 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55757 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55758 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55759 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55760 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55761 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55762 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55763 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55764 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55765 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55766 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55767 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55768 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55769 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55770 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55771 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55772 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55773 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55774 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55775 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55776 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55777 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55778 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55779 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55780 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55781 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55782 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55783 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55784 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55785 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55786 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55787 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55788 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55789 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55790 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55791 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55792 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55793 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55794 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55795 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55796 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55797 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55798 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55799 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55800 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55801 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55802 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55803 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55804 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55805 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55806 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55807 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55808 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55809 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55810 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55811 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55812 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55813 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55814 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55815 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55816 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55817 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55818 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55819 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55820 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55821 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55822 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55823 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55824 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55825 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55826 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55827 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55828 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55829 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55830 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55831 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55832 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55833 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55834 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55835 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55836 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55837 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55838 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55839 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55840 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55841 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55842 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55843 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55844 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55845 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55846 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55847 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55848 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55849 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55850 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55851 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55852 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55853 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55854 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55855 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55856 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55857 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55858 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55859 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55860 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55861 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55862 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55863 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55864 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55865 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55866 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55867 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55868 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55869 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55870 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55871 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55872 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55873 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55874 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55875 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55876 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55877 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55878 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55879 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55880 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55881 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55882 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55883 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55884 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55885 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55886 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55887 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55888 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55889 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55890 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55891 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55892 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55893 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55894 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55895 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55896 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55897 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55898 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55899 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55900 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55901 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55902 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55903 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55904 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55905 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55906 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55907 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55908 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55909 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55910 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55911 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55912 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55926 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55927 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55928 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55929 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55930 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55931 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55932 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55933 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55934 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55935 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55936 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55937 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55938 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55939 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55940 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55941 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55942 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55943 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55944 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55945 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55946 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55947 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55948 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55949 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55950 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55951 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55952 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55953 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55954 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55955 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55956 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55957 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55958 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55959 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55960 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55961 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55962 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55963 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55964 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55965 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55966 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55967 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55968 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55969 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55970 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55971 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55972 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55973 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55974 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55975 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55976 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55977 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55978 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55979 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55980 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55981 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55982 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55983 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55984 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55985 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55986 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55987 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55988 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55989 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55990 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55991 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55992 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55993 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55994 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55995 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55996 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55997 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55998 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55999 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56000 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56001 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56002 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56003 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56004 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56005 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56006 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56007 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56008 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56009 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56010 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56011 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56012 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56013 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56014 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56015 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56016 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56017 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56018 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56019 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56020 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56021 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56022 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56023 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56024 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56025 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56026 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56027 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56028 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56029 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56030 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56031 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56032 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56033 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56034 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56035 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56036 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56037 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56038 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56039 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56040 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56041 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56042 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56043 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56044 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56045 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56046 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56047 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56048 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56049 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56050 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56051 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56052 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56053 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56054 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56055 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56056 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56057 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56058 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56059 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56060 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56061 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56062 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56063 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56064 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56065 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56066 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56067 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56068 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56069 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56070 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56071 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56072 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56073 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56074 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56075 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56076 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56077 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56078 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56079 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56080 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56081 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56082 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56083 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56084 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56085 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56086 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56087 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56088 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56089 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56090 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56091 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56092 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56093 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56094 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56095 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56096 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56097 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56098 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56099 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56100 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56101 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56102 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56103 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56104 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56105 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56106 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56107 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56108 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56109 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56110 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56111 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56112 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56113 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56114 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56115 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56116 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56117 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56118 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56119 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56120 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56121 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56122 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56123 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56129 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56130 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56131 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56132 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56133 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56134 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56135 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56136 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56137 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56138 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56139 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56140 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56141 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56142 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56143 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56144 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56145 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56146 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56147 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56148 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56149 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56150 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56151 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56152 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56153 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56154 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56155 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56156 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56157 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56158 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56159 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56160 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56161 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56162 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56163 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56164 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56165 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56166 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56167
56168 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56169
56170
56171 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56172
56173 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56174 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56175 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56176 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56177 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56178 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56179 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56180 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56181 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56182 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56183 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56184 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56185 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56186 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56187 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56188 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56189 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56190 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56191 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56192 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56193 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56194 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56195 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56196 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56197 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56198 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56199 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56200 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56201 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56202 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56203 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56204 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56205 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56206 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56207 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56208 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56209 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56210 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56211 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56212 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56213 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56214 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56215 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56216 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56217 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56218 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56219 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56220 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56221 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56222 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56223 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56224 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56225 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56226 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56227 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56228 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56229 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56230 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56231 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56232 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56233 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56234 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56235 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56236 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56237 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56238 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56239 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56240 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56241 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56242 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56243 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56244 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56245 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56246 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56247 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56248 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56249 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56250 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56251 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56252 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56253 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56254 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56255 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56256 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56257 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56258 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56259 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56260 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56261 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56262 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56263 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56264 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56265 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56266 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56267 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56268 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56269 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56270 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56271 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56272 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56273 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56274 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56275 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56276 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56277 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56278 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56279 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56280 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56281 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56282 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56283 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56284 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56285 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56286 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56287 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56288 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56289 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56290 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56291 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56292 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56293 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56294 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56295 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56296 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56297 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56298 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56299 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56300 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56301 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56302 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56303 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56304 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56305 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56306 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56307 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56308 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56309 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56310 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56311 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56312 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56313 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56314 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56315 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56316 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56317 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56318 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56319 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56320 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56321 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56322 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56323 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56324 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56325 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56326 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56327 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56328 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56329 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56330 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56331 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56332 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56333 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56334 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56335 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56336 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56337 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56338 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56339 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56340 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56341 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56342 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56343 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56344 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56345 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56346 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56347 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56348 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56349 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56350 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56351 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56352 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56353 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56354 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56355 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56356 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56357 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56358 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56359 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56360 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56361 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56362 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56363 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56364 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56365 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56366 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56367 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56368 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56369 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56370 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56371 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56372 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56373 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56374 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56375 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56376 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56377
56378 // Initialize threading, some globals and such
56379 __wxPyPreStart(d);
56380
56381
56382 // Although these are defined in __version__ they need to be here too so
56383 // that an assert can be done to ensure that the wxPython and the wxWindows
56384 // versions match.
56385 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56386 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56387 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56388
56389 }
56390
wxWidgets (Impactor)